From 8cf1aaca1ccbb61715137a952c8dfda0a06cb35f Mon Sep 17 00:00:00 2001 From: Steven He Date: Fri, 22 Sep 2023 20:15:42 +0900 Subject: [PATCH 1/7] Adding WIC --- build/cache/wic.json.gz | Bin 0 -> 59823 bytes build/cache/win32extras.json.gz | Bin 252948 -> 280774 bytes build/include/silk.net.windowscodecs.h | 7 + generator.json | 117 +- .../Enums/TagADVF.gen.cs | 54 + .../Enums/TagApplicationType.gen.cs | 20 + .../Enums/TagBINDFLAGS.gen.cs | 26 + .../Enums/TagCALLTYPE.gen.cs | 41 + .../Enums/TagDATADIR.gen.cs | 26 + .../Enums/TagMKREDUCE.gen.cs | 37 + .../Enums/TagMKSYS.gen.cs | 66 + .../Enums/TagPENDINGMSG.gen.cs | 31 + .../Enums/TagPENDINGTYPE.gen.cs | 26 + .../Enums/TagSERVERCALL.gen.cs | 31 + .../Enums/TagShutdownType.gen.cs | 20 + .../Enums/TagTYMED.gen.cs | 57 + .../Structs/AdviseSink2VtblExtensions.gen.cs | 272 + .../Structs/AdviseSinkVtblExtensions.gen.cs | 239 + .../ApartmentShutdownVtblExtensions.gen.cs | 128 + .../Structs/AsyncIAdviseSink.gen.cs | 253 + .../Structs/AsyncIAdviseSink2.gen.cs | 288 + .../AsyncIAdviseSink2VtblExtensions.gen.cs | 314 + .../AsyncIAdviseSinkVtblExtensions.gen.cs | 274 + .../Structs/BindCtxVtblExtensions.gen.cs | 602 + .../Structs/BlockingLockVtblExtensions.gen.cs | 139 + .../ClassActivatorVtblExtensions.gen.cs | 313 + .../DataAdviseHolderVtblExtensions.gen.cs | 652 + .../Structs/DataObjectVtblExtensions.gen.cs | 701 + .../DirectWriterLockVtblExtensions.gen.cs | 148 + .../DummyHICONIncluderVtblExtensions.gen.cs | 150 + .../EnumFORMATETCVtblExtensions.gen.cs | 240 + .../Structs/EnumMonikerVtblExtensions.gen.cs | 248 + .../Structs/EnumSTATDATAVtblExtensions.gen.cs | 240 + .../Structs/EnumSTATSTGVtblExtensions.gen.cs | 240 + .../FillLockBytesVtblExtensions.gen.cs | 283 + .../Structs/FlagStgmedium.gen.cs | 61 + .../ForegroundTransferVtblExtensions.gen.cs | 150 + .../Structs/IAdviseSink.gen.cs | 218 + .../Structs/IAdviseSink2.gen.cs | 246 + .../Structs/IApartmentShutdown.gen.cs | 139 + .../Structs/IBindCtx.gen.cs | 525 + .../Structs/IBlockingLock.gen.cs | 150 + .../Structs/IClassActivator.gen.cs | 276 + .../Structs/IDataAdviseHolder.gen.cs | 535 + .../Structs/IDataObject.gen.cs | 552 + .../Structs/IDirectWriterLock.gen.cs | 159 + .../Structs/IDummyHICONIncluder.gen.cs | 153 + .../Structs/IEnumFORMATETC.gen.cs | 227 + .../Structs/IEnumMoniker.gen.cs | 243 + .../Structs/IEnumSTATDATA.gen.cs | 227 + .../Structs/IEnumSTATSTG.gen.cs | 227 + .../Structs/IFillLockBytes.gen.cs | 246 + .../Structs/IForegroundTransfer.gen.cs | 153 + .../Structs/IInitializeSpy.gen.cs | 168 + .../Structs/ILayoutStorage.gen.cs | 232 + .../Structs/ILockBytes.gen.cs | 285 + .../Structs/IMallocSpy.gen.cs | 345 + .../Structs/IMessageFilter.gen.cs | 222 + .../Structs/IMoniker.gen.cs | 3184 ++ .../Structs/IOplockStorage.gen.cs | 568 + .../Structs/IPersist.gen.cs | 153 + .../Structs/IPersistFile.gen.cs | 294 + .../Structs/IPersistStorage.gen.cs | 290 + .../Structs/IPersistStream.gen.cs | 244 + .../Structs/IProcessLock.gen.cs | 150 + .../Structs/IProgressNotify.gen.cs | 141 + .../Structs/IROTData.gen.cs | 205 + .../Structs/IRootStorage.gen.cs | 164 + .../Structs/IRunnableObject.gen.cs | 209 + .../Structs/IRunningObjectTable.gen.cs | 512 + .../Structs/IStorage.gen.cs | 2339 ++ .../Structs/ISurrogateService.gen.cs | 332 + .../Structs/IThumbnailExtractor.gen.cs | 465 + .../Structs/ITimeAndNoticeControl.gen.cs | 141 + .../Structs/IUrlMon.gen.cs | 4992 +++ .../InitializeSpyVtblExtensions.gen.cs | 157 + .../LayoutStorageVtblExtensions.gen.cs | 245 + .../Structs/LockBytesVtblExtensions.gen.cs | 330 + .../Structs/MallocSpyVtblExtensions.gen.cs | 398 + .../MessageFilterVtblExtensions.gen.cs | 251 + .../Structs/MonikerVtblExtensions.gen.cs | 4039 +++ .../OplockStorageVtblExtensions.gen.cs | 685 + .../Structs/PersistFileVtblExtensions.gen.cs | 312 + .../PersistStorageVtblExtensions.gen.cs | 316 + .../PersistStreamVtblExtensions.gen.cs | 262 + .../Structs/PersistVtblExtensions.gen.cs | 150 + .../Structs/ProcessLockVtblExtensions.gen.cs | 139 + .../ProgressNotifyVtblExtensions.gen.cs | 130 + .../Structs/ROTDataVtblExtensions.gen.cs | 226 + .../Structs/RootStorageVtblExtensions.gen.cs | 161 + .../RunnableObjectVtblExtensions.gen.cs | 214 + .../RunningObjectTableVtblExtensions.gen.cs | 613 + .../Structs/StorageVtblExtensions.gen.cs | 2968 ++ .../SurrogateServiceVtblExtensions.gen.cs | 393 + .../Structs/TagBINDOPTS.gen.cs | 72 + .../Structs/TagBINDOPTS2.gen.cs | 116 + .../Structs/TagBINDOPTS3.gen.cs | 83 + .../Structs/TagDVTARGETDEVICE.gen.cs | 87 + .../Structs/TagFORMATETC.gen.cs | 83 + .../Structs/TagINTERFACEINFO.gen.cs | 61 + .../Structs/TagRemSNB.gen.cs | 55 + .../Structs/TagRemSTGMEDIUM.gen.cs | 87 + .../Structs/TagSTATDATA.gen.cs | 72 + .../Structs/TagSTGMEDIUM.gen.cs | 202 + .../Structs/TagSTGMEDIUMUnion.gen.cs | 113 + .../Structs/TagStorageLayout.gen.cs | 73 + .../ThumbnailExtractorVtblExtensions.gen.cs | 574 + .../TimeAndNoticeControlVtblExtensions.gen.cs | 130 + .../Structs/UrlMonVtblExtensions.gen.cs | 6645 ++++ .../Structs/UserFLAGSTGMEDIUM.gen.cs | 61 + .../Structs/UserSTGMEDIUM.gen.cs | 39 + .../Silk.NET.Core.Win32Extras/Windows.gen.cs | 26150 ++++++++++++++-- .../WindowsOverloads.gen.cs | 13136 ++++++++ src/Core/Silk.NET.Core/win32extras.h | 1 + .../Enums/WIC8BIMIptcDigestProperties.gen.cs | 31 + .../Enums/WIC8BIMIptcProperties.gen.cs | 31 + .../WIC8BIMResolutionInfoProperties.gen.cs | 56 + .../Enums/WICBitmapAlphaChannelOption.gen.cs | 36 + .../Enums/WICBitmapCreateCacheOption.gen.cs | 36 + .../Enums/WICBitmapDecoderCapabilities.gen.cs | 49 + .../Enums/WICBitmapDitherType.gen.cs | 71 + .../Enums/WICBitmapEncoderCacheOption.gen.cs | 36 + .../Enums/WICBitmapInterpolationMode.gen.cs | 46 + .../Enums/WICBitmapLockFlags.gen.cs | 31 + .../Enums/WICBitmapPaletteType.gen.cs | 91 + .../Enums/WICBitmapTransformOptions.gen.cs | 52 + .../Enums/WICColorContextType.gen.cs | 31 + .../Enums/WICComponentEnumerateOptions.gen.cs | 47 + .../Enums/WICComponentSigning.gen.cs | 44 + .../Enums/WICComponentType.gen.cs | 59 + .../Enums/WICDdsAlphaMode.gen.cs | 46 + .../Enums/WICDdsDimension.gen.cs | 41 + .../Enums/WICDecodeOptions.gen.cs | 31 + ...ICGifApplicationExtensionProperties.gen.cs | 31 + .../WICGifCommentExtensionProperties.gen.cs | 26 + ...ifGraphicControlExtensionProperties.gen.cs | 46 + .../WICGifImageDescriptorProperties.gen.cs | 61 + ...ifLogicalScreenDescriptorProperties.gen.cs | 66 + .../Enums/WICHeifHdrProperties.gen.cs | 46 + .../Enums/WICHeifProperties.gen.cs | 26 + .../Enums/WICJpegChrominanceProperties.gen.cs | 26 + .../Enums/WICJpegCommentProperties.gen.cs | 26 + .../Enums/WICJpegIndexingOptions.gen.cs | 31 + .../Enums/WICJpegLuminanceProperties.gen.cs | 26 + .../Enums/WICJpegScanType.gen.cs | 36 + .../Enums/WICJpegTransferMatrix.gen.cs | 31 + .../WICJpegYCrCbSubsamplingOption.gen.cs | 46 + .../Enums/WICMetadataCreationOptions.gen.cs | 36 + .../Enums/WICNamedWhitePoint.gen.cs | 79 + .../Enums/WICPersistOptions.gen.cs | 52 + ...WICPixelFormatNumericRepresentation.gen.cs | 51 + .../Enums/WICPlanarOptions.gen.cs | 31 + .../Enums/WICPngBkgdProperties.gen.cs | 26 + .../Enums/WICPngChrmProperties.gen.cs | 61 + .../Enums/WICPngFilterOption.gen.cs | 56 + .../Enums/WICPngGamaProperties.gen.cs | 26 + .../Enums/WICPngHistProperties.gen.cs | 26 + .../Enums/WICPngIccpProperties.gen.cs | 31 + .../Enums/WICPngItxtProperties.gen.cs | 46 + .../Enums/WICPngSrgbProperties.gen.cs | 26 + .../Enums/WICPngTimeProperties.gen.cs | 51 + .../Enums/WICProgressNotification.gen.cs | 44 + .../Enums/WICProgressOperation.gen.cs | 39 + .../Enums/WICRawCapabilities.gen.cs | 36 + .../Enums/WICRawParameterSet.gen.cs | 36 + .../Enums/WICRawRenderMode.gen.cs | 36 + .../Enums/WICRawRotationCapabilities.gen.cs | 41 + .../Enums/WICSectionAccessLevel.gen.cs | 34 + .../Enums/WICTiffCompressionOption.gen.cs | 61 + .../Enums/WICWebpAnimProperties.gen.cs | 26 + .../Enums/WICWebpAnmfProperties.gen.cs | 26 + .../WindowsCodecs/Structs/IWICBitmap.gen.cs | 456 + .../Structs/IWICBitmapClipper.gen.cs | 418 + .../Structs/IWICBitmapCodecInfo.gen.cs | 1102 + ...IWICBitmapCodecProgressNotification.gen.cs | 153 + .../Structs/IWICBitmapDecoder.gen.cs | 505 + .../Structs/IWICBitmapDecoderInfo.gen.cs | 1306 + .../Structs/IWICBitmapEncoder.gen.cs | 437 + .../Structs/IWICBitmapEncoderInfo.gen.cs | 1134 + .../Structs/IWICBitmapFlipRotator.gen.cs | 383 + .../Structs/IWICBitmapFrameDecode.gen.cs | 476 + .../Structs/IWICBitmapFrameEncode.gen.cs | 421 + .../Structs/IWICBitmapLock.gen.cs | 294 + .../Structs/IWICBitmapScaler.gen.cs | 383 + .../Structs/IWICBitmapSource.gen.cs | 351 + .../Structs/IWICBitmapSourceTransform.gen.cs | 386 + .../Structs/IWICColorContext.gen.cs | 320 + .../Structs/IWICColorTransform.gen.cs | 706 + .../Structs/IWICComponentFactory.gen.cs | 3514 +++ .../Structs/IWICComponentInfo.gen.cs | 508 + .../Structs/IWICDdsDecoder.gen.cs | 182 + .../Structs/IWICDdsEncoder.gen.cs | 478 + .../Structs/IWICDdsFrameDecode.gen.cs | 274 + .../Structs/IWICDevelopRaw.gen.cs | 1220 + .../IWICDevelopRawNotificationCallback.gen.cs | 141 + .../Structs/IWICEnumMetadataItem.gen.cs | 419 + .../Structs/IWICFastMetadataEncoder.gen.cs | 170 + .../Structs/IWICFormatConverter.gen.cs | 618 + .../Structs/IWICFormatConverterInfo.gen.cs | 588 + .../Structs/IWICImageEncoder.gen.cs | 552 + .../Structs/IWICImagingFactory.gen.cs | 2315 ++ .../Structs/IWICImagingFactory2.gen.cs | 2382 ++ .../Structs/IWICJpegFrameDecode.gen.cs | 422 + .../Structs/IWICJpegFrameEncode.gen.cs | 227 + .../Structs/IWICMetadataBlockReader.gen.cs | 224 + .../Structs/IWICMetadataBlockWriter.gen.cs | 352 + .../Structs/IWICMetadataHandlerInfo.gen.cs | 789 + .../Structs/IWICMetadataQueryReader.gen.cs | 320 + .../Structs/IWICMetadataQueryWriter.gen.cs | 428 + .../Structs/IWICMetadataReader.gen.cs | 448 + .../Structs/IWICMetadataReaderInfo.gen.cs | 1201 + .../Structs/IWICMetadataWriter.gen.cs | 724 + .../Structs/IWICMetadataWriterInfo.gen.cs | 929 + .../WindowsCodecs/Structs/IWICPalette.gen.cs | 373 + .../Structs/IWICPersistStream.gen.cs | 340 + .../Structs/IWICPixelFormatInfo.gen.cs | 676 + .../Structs/IWICPixelFormatInfo2.gen.cs | 721 + .../IWICPlanarBitmapFrameEncode.gen.cs | 217 + .../IWICPlanarBitmapSourceTransform.gen.cs | 708 + .../Structs/IWICPlanarFormatConverter.gen.cs | 618 + .../Structs/IWICProgressCallback.gen.cs | 141 + .../IWICProgressiveLevelControl.gen.cs | 183 + .../WindowsCodecs/Structs/IWICStream.gen.cs | 612 + .../Structs/IWICStreamProvider.gen.cs | 212 + .../Structs/PfnProgressNotification.gen.cs | 53 + .../WICBitmapClipperVtblExtensions.gen.cs | 524 + .../WICBitmapCodecInfoVtblExtensions.gen.cs | 1504 + ...cProgressNotificationVtblExtensions.gen.cs | 150 + .../WICBitmapDecoderInfoVtblExtensions.gen.cs | 1785 ++ .../WICBitmapDecoderVtblExtensions.gen.cs | 566 + .../WICBitmapEncoderInfoVtblExtensions.gen.cs | 1533 + .../WICBitmapEncoderVtblExtensions.gen.cs | 466 + .../WICBitmapFlipRotatorVtblExtensions.gen.cs | 473 + .../WICBitmapFrameDecodeVtblExtensions.gen.cs | 574 + .../WICBitmapFrameEncodeVtblExtensions.gen.cs | 474 + .../WICBitmapLockVtblExtensions.gen.cs | 339 + .../Structs/WICBitmapPattern.gen.cs | 83 + .../Structs/WICBitmapPlane.gen.cs | 72 + .../Structs/WICBitmapPlaneDescription.gen.cs | 61 + .../WICBitmapScalerVtblExtensions.gen.cs | 473 + ...BitmapSourceTransformVtblExtensions.gen.cs | 495 + .../WICBitmapSourceVtblExtensions.gen.cs | 436 + .../Structs/WICBitmapVtblExtensions.gen.cs | 562 + .../WICColorContextVtblExtensions.gen.cs | 373 + .../WICColorTransformVtblExtensions.gen.cs | 908 + .../WICComponentFactoryVtblExtensions.gen.cs | 4412 +++ .../WICComponentInfoVtblExtensions.gen.cs | 657 + .../WICDdsDecoderVtblExtensions.gen.cs | 179 + .../WICDdsEncoderVtblExtensions.gen.cs | 595 + .../Structs/WICDdsFormatInfo.gen.cs | 72 + .../WICDdsFrameDecodeVtblExtensions.gen.cs | 327 + .../Structs/WICDdsParameters.gen.cs | 116 + ...wNotificationCallbackVtblExtensions.gen.cs | 130 + .../WICDevelopRawVtblExtensions.gen.cs | 1571 + .../WICEnumMetadataItemVtblExtensions.gen.cs | 528 + ...ICFastMetadataEncoderVtblExtensions.gen.cs | 159 + ...ICFormatConverterInfoVtblExtensions.gen.cs | 758 + .../WICFormatConverterVtblExtensions.gen.cs | 812 + .../WICImageEncoderVtblExtensions.gen.cs | 709 + .../Structs/WICImageParameters.gen.cs | 105 + .../WICImagingFactory2VtblExtensions.gen.cs | 2928 ++ .../WICImagingFactoryVtblExtensions.gen.cs | 2848 ++ .../WICJpegFrameDecodeVtblExtensions.gen.cs | 523 + .../WICJpegFrameEncodeVtblExtensions.gen.cs | 248 + .../Structs/WICJpegFrameHeader.gen.cs | 116 + .../Structs/WICJpegScanHeader.gen.cs | 116 + ...ICMetadataBlockReaderVtblExtensions.gen.cs | 229 + ...ICMetadataBlockWriterVtblExtensions.gen.cs | 378 + ...ICMetadataHandlerInfoVtblExtensions.gen.cs | 1055 + .../Structs/WICMetadataHeader.gen.cs | 72 + .../Structs/WICMetadataPattern.gen.cs | 83 + ...ICMetadataQueryReaderVtblExtensions.gen.cs | 381 + ...ICMetadataQueryWriterVtblExtensions.gen.cs | 526 + ...WICMetadataReaderInfoVtblExtensions.gen.cs | 1640 + .../WICMetadataReaderVtblExtensions.gen.cs | 565 + ...WICMetadataWriterInfoVtblExtensions.gen.cs | 1248 + .../WICMetadataWriterVtblExtensions.gen.cs | 974 + .../Structs/WICPaletteVtblExtensions.gen.cs | 450 + .../WICPersistStreamVtblExtensions.gen.cs | 387 + .../WICPixelFormatInfo2VtblExtensions.gen.cs | 936 + .../WICPixelFormatInfoVtblExtensions.gen.cs | 878 + ...anarBitmapFrameEncodeVtblExtensions.gen.cs | 230 + ...BitmapSourceTransformVtblExtensions.gen.cs | 969 + ...PlanarFormatConverterVtblExtensions.gen.cs | 804 + .../WICProgressCallbackVtblExtensions.gen.cs | 130 + ...ogressiveLevelControlVtblExtensions.gen.cs | 188 + .../Structs/WICRawCapabilitiesInfo.gen.cs | 226 + .../Structs/WICRawToneCurve.gen.cs | 70 + .../Structs/WICRawToneCurvePoint.gen.cs | 50 + .../WindowsCodecs/Structs/WICRect.gen.cs | 72 + .../WICStreamProviderVtblExtensions.gen.cs | 217 + .../Structs/WICStreamVtblExtensions.gen.cs | 747 + .../WindowsCodecs/WICLibraryNameContainer.cs | 31 + .../WindowsCodecs/WindowsCodecs.cs | 38 + .../WindowsCodecs/WindowsCodecs.gen.cs | 6011 ++++ .../WindowsCodecsOverloads.gen.cs | 4061 +++ 296 files changed, 172965 insertions(+), 2551 deletions(-) create mode 100644 build/cache/wic.json.gz create mode 100644 build/include/silk.net.windowscodecs.h create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ApartmentShutdownVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/BlockingLockVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ClassActivatorVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/DirectWriterLockVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/DummyHICONIncluderVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumMonikerVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATSTGVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/FillLockBytesVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ForegroundTransferVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IApartmentShutdown.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IBlockingLock.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IClassActivator.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IDirectWriterLock.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IDummyHICONIncluder.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumMoniker.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATSTG.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IFillLockBytes.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IForegroundTransfer.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IInitializeSpy.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ILockBytes.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IMallocSpy.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IMoniker.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IOplockStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPersist.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistFile.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStream.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IProcessLock.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IProgressNotify.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IROTData.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IRootStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IRunnableObject.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IRunningObjectTable.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IStorage.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IThumbnailExtractor.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ITimeAndNoticeControl.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/IUrlMon.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/InitializeSpyVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/LockBytesVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/MallocSpyVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/MonikerVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/OplockStorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PersistFileVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/PersistVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ProcessLockVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ProgressNotifyVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ROTDataVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/RootStorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/RunnableObjectVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/RunningObjectTableVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/StorageVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/ThumbnailExtractorVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/TimeAndNoticeControlVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/UrlMonVtblExtensions.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/UserFLAGSTGMEDIUM.gen.cs create mode 100644 src/Core/Silk.NET.Core.Win32Extras/Structs/UserSTGMEDIUM.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecProgressNotification.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapLock.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRawNotificationCallback.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFastMetadataEncoder.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameEncode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockReader.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockWriter.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPersistStream.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressiveLevelControl.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStream.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStreamProvider.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecProgressNotificationVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapLockVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawNotificationCallbackVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFastMetadataEncoderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameEncodeVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockReaderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockWriterVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPersistStreamVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressiveLevelControlVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamProviderVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamVtblExtensions.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WICLibraryNameContainer.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs create mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs diff --git a/build/cache/wic.json.gz b/build/cache/wic.json.gz new file mode 100644 index 0000000000000000000000000000000000000000..2693ba649fcdb642cf56c15ebc74678f98721fa1 GIT binary patch literal 59823 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⪙}zQ#n%Osz3OG1=HGg3f=e`M_OFfi6 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

GVIcnH}SRB9#0e*lC~>7T@fwOOzlD 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 LFi{G?`Fqp=KEUmY literal 252948 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 diff --git a/build/include/silk.net.windowscodecs.h b/build/include/silk.net.windowscodecs.h new file mode 100644 index 0000000000..0c2e5cf2ad --- /dev/null +++ b/build/include/silk.net.windowscodecs.h @@ -0,0 +1,7 @@ +typedef unsigned int UINT32; +typedef float FLOAT; + +#include +#include +#include +#include diff --git a/generator.json b/generator.json index 5b0c438c2b..054063b14f 100644 --- a/generator.json +++ b/generator.json @@ -1020,6 +1020,7 @@ "$windowsSdkDir/Include/$windowsSdkVersion/um/handleapi.h", "$windowsSdkDir/Include/$windowsSdkVersion/um/fileapi.h", "$windowsSdkDir/Include/$windowsSdkVersion/um/objidlbase.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/objidl.h", "$windowsSdkDir/Include/$windowsSdkVersion/um/Documenttarget.h", "$windowsSdkDir/Include/$windowsSdkVersion/shared/evntprov.h" ], @@ -1028,7 +1029,11 @@ } }, "exclude": [ - "_SECURITY_ATTRIBUTES" + "_SECURITY_ATTRIBUTES", + "_STGMEDIUM_UNION", + "_GDI_OBJECT", + "__MIDL_IAdviseSink_0002", + "__MIDL_IAdviseSink_0003" ], "rename": { "ETW_COMPRESSION_RESUMPTION_MODE": "EtwCompressionResumptionMode", @@ -1073,7 +1078,10 @@ "tagCY": "CY", "tagDEC": "TagDecimal", "tagSAFEARRAYBOUND": "SafeArrayBound", - "PfnTagEXCEPINFOvI": "PfnExceptionInfovI" + "PfnTagEXCEPINFOvI": "PfnExceptionInfovI", + "HICON__": "void", + "HBITMAP__": "void", + "HTASK__": "void" }, { "$include.dxTypemap": "build/dx_typemap.json", @@ -1531,6 +1539,109 @@ } ] }, + { + "profileName": "WindowsCodecs", + "sources": [ + "build/include/silk.net.windowscodecs.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/wincodec.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/wincodecsdk.h" + ], + "mode": "Clang", + "cacheDir": "build/cache", + "cacheKey": "wic", + "controlDescriptors": [ + "convert-windows-only", + "typemap-native", + "no-pre-2.17-obsolete-enums", + "no-csproj", + "no-extra-dir" + ], + "converter": {}, + "prefix": "WIC_", + "clang": { + "args": [ + "--language=c++", + "--std=c++17", + "-m32", + "-Wno-expansion-to-defined", + "-Wno-ignored-attributes", + "-Wno-ignored-pragma-intrinsic", + "-Wno-nonportable-include-path", + "-Wno-pragma-pack", + "-I$windowsSdkIncludes", + "-Ibuild/include" + ], + "traverse": [ + "$windowsSdkDir/Include/$windowsSdkVersion/um/wincodec.h", + "$windowsSdkDir/Include/$windowsSdkVersion/um/wincodecsdk.h" + ], + "classes": { + "silk.net.windowscodecs.h": "[Core]WindowsCodecs", + "wincodec.h": "[Core]WindowsCodecs", + "wincodecsdk.h": "[Core]WindowsCodecs", + "wincodec_proxy.h": "[Core]WindowsCodecs" + } + }, + "exclude": [ + "ID2D1Device", + "ID2D1Image" + ], + "rename": {}, + "bakery": { + "profileNames": [ + "silk.net.windowscodecs", + "windowscodecs" + ] + }, + "output": { + "mode": "Default", + "path": "src/Microsoft/Silk.NET.Direct2D", + "innerPath": "WindowsCodecs", + "licenseFile": "build/LICENSE_HEADER.txt", + "props": "build/props/bindings.props" + }, + "namespace": "Silk.NET.WindowsCodecs", + "extensionsNamespace": "Silk.NET.WindowsCodecs.Extensions", + "nameContainer": { + "linux-x64": "libwindowscodecs.so", + "win-x64": "windowscodecs.dll", + "win-x86": "windowscodecs.dll", + "osx-x64": "libwindowscodecs.dylib", + "android": "libwindowscodecs.so", + "iOS": "__Internal", + "className": "WICLibraryNameContainer" + }, + "typeMaps": [ + { + "ID2D1Device": "Silk.NET.Direct2D.ID2D1Device", + "ID2D1Image": "Silk.NET.Direct2D.ID2D1Image", + "D2D1_PIXEL_FORMAT": "Silk.NET.Direct2D.PixelFormat", + "DXGI_JPEG_QUANTIZATION_TABLE": "Silk.NET.DXGI.JpegQuantizationTable", + "DXGI_JPEG_AC_HUFFMAN_TABLE": "Silk.NET.DXGI.JpegACHuffmanTable", + "DXGI_JPEG_DC_HUFFMAN_TABLE": "Silk.NET.DXGI.JpegDCHuffmanTable", + "DXGI_FORMAT": "Silk.NET.DXGI.Format", + "_RPC_MESSAGE": "Silk.NET.Core.Win32Extras.RPCMessage", + "IRpcStubBuffer": "Silk.NET.Core.Win32Extras.IRpcStubBuffer", + "IRpcChannelBuffer": "Silk.NET.Core.Win32Extras.IRpcChannelBuffer", + "ISequentialStream": "Silk.NET.Core.Win32Extras.ISequentialStream", + "IPersist": "Silk.NET.Core.Win32Extras.IPersist", + "IPersistStream": "Silk.NET.Core.Win32Extras.IPersistStream", + "IPropertyBag2": "Silk.NET.Core.Native.IUnknown", + "IEnumUnknown": "Silk.NET.Core.Win32Extras.IEnumUnknown", + "IEnumString": "Silk.NET.Core.Win32Extras.IEnumString", + "tagSAFEARRAY": "Silk.NET.Core.Win32Extras.SafeArray", + "tagSTATSTG": "Silk.NET.Core.Win32Extras.STATSTG", + "tagPROPVARIANT": "void", + "tagPROPBAG2": "void", + "HPALETTE__": "void", + "HBITMAP__": "void", + "HICON__": "void" + }, + { + "$include.commonTypeMap": "build/csharp_typemap.json" + } + ] + }, { "profileName": "D3D11", "sources": [ @@ -2757,4 +2868,4 @@ ] } ] -} \ No newline at end of file +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs new file mode 100644 index 0000000000..39927568b6 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs @@ -0,0 +1,54 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagADVF")] + public enum TagADVF : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Nodata\"")] + [NativeName("Name", "ADVF_NODATA")] + AdvfNodata = 0x1, + [Obsolete("Deprecated in favour of \"Primefirst\"")] + [NativeName("Name", "ADVF_PRIMEFIRST")] + AdvfPrimefirst = 0x2, + [Obsolete("Deprecated in favour of \"Onlyonce\"")] + [NativeName("Name", "ADVF_ONLYONCE")] + AdvfOnlyonce = 0x4, + [Obsolete("Deprecated in favour of \"Dataonstop\"")] + [NativeName("Name", "ADVF_DATAONSTOP")] + AdvfDataonstop = 0x40, + [Obsolete("Deprecated in favour of \"AcheNohandler\"")] + [NativeName("Name", "ADVFCACHE_NOHANDLER")] + AdvfcacheNohandler = 0x8, + [Obsolete("Deprecated in favour of \"AcheForcebuiltin\"")] + [NativeName("Name", "ADVFCACHE_FORCEBUILTIN")] + AdvfcacheForcebuiltin = 0x10, + [Obsolete("Deprecated in favour of \"AcheOnsave\"")] + [NativeName("Name", "ADVFCACHE_ONSAVE")] + AdvfcacheOnsave = 0x20, + [NativeName("Name", "ADVF_NODATA")] + Nodata = 0x1, + [NativeName("Name", "ADVF_PRIMEFIRST")] + Primefirst = 0x2, + [NativeName("Name", "ADVF_ONLYONCE")] + Onlyonce = 0x4, + [NativeName("Name", "ADVF_DATAONSTOP")] + Dataonstop = 0x40, + [NativeName("Name", "ADVFCACHE_NOHANDLER")] + AcheNohandler = 0x8, + [NativeName("Name", "ADVFCACHE_FORCEBUILTIN")] + AcheForcebuiltin = 0x10, + [NativeName("Name", "ADVFCACHE_ONSAVE")] + AcheOnsave = 0x20, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs new file mode 100644 index 0000000000..4d56c908fd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagApplicationType")] + public enum TagApplicationType : int + { + [NativeName("Name", "ServerApplication")] + ServerApplication = 0x0, + [NativeName("Name", "LibraryApplication")] + LibraryApplication = 0x1, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs new file mode 100644 index 0000000000..421dd594cd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagBIND_FLAGS")] + public enum TagBINDFLAGS : int + { + [Obsolete("Deprecated in favour of \"Maybotheruser\"")] + [NativeName("Name", "BIND_MAYBOTHERUSER")] + BindMaybotheruser = 0x1, + [Obsolete("Deprecated in favour of \"Justtestexistence\"")] + [NativeName("Name", "BIND_JUSTTESTEXISTENCE")] + BindJusttestexistence = 0x2, + [NativeName("Name", "BIND_MAYBOTHERUSER")] + Maybotheruser = 0x1, + [NativeName("Name", "BIND_JUSTTESTEXISTENCE")] + Justtestexistence = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs new file mode 100644 index 0000000000..f169632b96 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagCALLTYPE")] + public enum TagCALLTYPE : int + { + [Obsolete("Deprecated in favour of \"Toplevel\"")] + [NativeName("Name", "CALLTYPE_TOPLEVEL")] + CalltypeToplevel = 0x1, + [Obsolete("Deprecated in favour of \"Nested\"")] + [NativeName("Name", "CALLTYPE_NESTED")] + CalltypeNested = 0x2, + [Obsolete("Deprecated in favour of \"Async\"")] + [NativeName("Name", "CALLTYPE_ASYNC")] + CalltypeAsync = 0x3, + [Obsolete("Deprecated in favour of \"ToplevelCallpending\"")] + [NativeName("Name", "CALLTYPE_TOPLEVEL_CALLPENDING")] + CalltypeToplevelCallpending = 0x4, + [Obsolete("Deprecated in favour of \"AsyncCallpending\"")] + [NativeName("Name", "CALLTYPE_ASYNC_CALLPENDING")] + CalltypeAsyncCallpending = 0x5, + [NativeName("Name", "CALLTYPE_TOPLEVEL")] + Toplevel = 0x1, + [NativeName("Name", "CALLTYPE_NESTED")] + Nested = 0x2, + [NativeName("Name", "CALLTYPE_ASYNC")] + Async = 0x3, + [NativeName("Name", "CALLTYPE_TOPLEVEL_CALLPENDING")] + ToplevelCallpending = 0x4, + [NativeName("Name", "CALLTYPE_ASYNC_CALLPENDING")] + AsyncCallpending = 0x5, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs new file mode 100644 index 0000000000..9962e8a729 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagDATADIR")] + public enum TagDATADIR : int + { + [Obsolete("Deprecated in favour of \"Get\"")] + [NativeName("Name", "DATADIR_GET")] + DatadirGet = 0x1, + [Obsolete("Deprecated in favour of \"Set\"")] + [NativeName("Name", "DATADIR_SET")] + DatadirSet = 0x2, + [NativeName("Name", "DATADIR_GET")] + Get = 0x1, + [NativeName("Name", "DATADIR_SET")] + Set = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs new file mode 100644 index 0000000000..a39ae6e118 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs @@ -0,0 +1,37 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagMKREDUCE")] + public enum TagMKREDUCE : int + { + [Obsolete("Deprecated in favour of \"One\"")] + [NativeName("Name", "MKRREDUCE_ONE")] + MkrreduceOne = 0x30000, + [Obsolete("Deprecated in favour of \"Touser\"")] + [NativeName("Name", "MKRREDUCE_TOUSER")] + MkrreduceTouser = 0x20000, + [Obsolete("Deprecated in favour of \"Throughuser\"")] + [NativeName("Name", "MKRREDUCE_THROUGHUSER")] + MkrreduceThroughuser = 0x10000, + [Obsolete("Deprecated in favour of \"All\"")] + [NativeName("Name", "MKRREDUCE_ALL")] + MkrreduceAll = 0x0, + [NativeName("Name", "MKRREDUCE_ONE")] + One = 0x30000, + [NativeName("Name", "MKRREDUCE_TOUSER")] + Touser = 0x20000, + [NativeName("Name", "MKRREDUCE_THROUGHUSER")] + Throughuser = 0x10000, + [NativeName("Name", "MKRREDUCE_ALL")] + All = 0x0, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs new file mode 100644 index 0000000000..6f76e50214 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs @@ -0,0 +1,66 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagMKSYS")] + public enum TagMKSYS : int + { + [Obsolete("Deprecated in favour of \"None\"")] + [NativeName("Name", "MKSYS_NONE")] + MksysNone = 0x0, + [Obsolete("Deprecated in favour of \"Genericcomposite\"")] + [NativeName("Name", "MKSYS_GENERICCOMPOSITE")] + MksysGenericcomposite = 0x1, + [Obsolete("Deprecated in favour of \"Filemoniker\"")] + [NativeName("Name", "MKSYS_FILEMONIKER")] + MksysFilemoniker = 0x2, + [Obsolete("Deprecated in favour of \"Antimoniker\"")] + [NativeName("Name", "MKSYS_ANTIMONIKER")] + MksysAntimoniker = 0x3, + [Obsolete("Deprecated in favour of \"Itemmoniker\"")] + [NativeName("Name", "MKSYS_ITEMMONIKER")] + MksysItemmoniker = 0x4, + [Obsolete("Deprecated in favour of \"Pointermoniker\"")] + [NativeName("Name", "MKSYS_POINTERMONIKER")] + MksysPointermoniker = 0x5, + [Obsolete("Deprecated in favour of \"Classmoniker\"")] + [NativeName("Name", "MKSYS_CLASSMONIKER")] + MksysClassmoniker = 0x7, + [Obsolete("Deprecated in favour of \"Objrefmoniker\"")] + [NativeName("Name", "MKSYS_OBJREFMONIKER")] + MksysObjrefmoniker = 0x8, + [Obsolete("Deprecated in favour of \"Sessionmoniker\"")] + [NativeName("Name", "MKSYS_SESSIONMONIKER")] + MksysSessionmoniker = 0x9, + [Obsolete("Deprecated in favour of \"Luamoniker\"")] + [NativeName("Name", "MKSYS_LUAMONIKER")] + MksysLuamoniker = 0xA, + [NativeName("Name", "MKSYS_NONE")] + None = 0x0, + [NativeName("Name", "MKSYS_GENERICCOMPOSITE")] + Genericcomposite = 0x1, + [NativeName("Name", "MKSYS_FILEMONIKER")] + Filemoniker = 0x2, + [NativeName("Name", "MKSYS_ANTIMONIKER")] + Antimoniker = 0x3, + [NativeName("Name", "MKSYS_ITEMMONIKER")] + Itemmoniker = 0x4, + [NativeName("Name", "MKSYS_POINTERMONIKER")] + Pointermoniker = 0x5, + [NativeName("Name", "MKSYS_CLASSMONIKER")] + Classmoniker = 0x7, + [NativeName("Name", "MKSYS_OBJREFMONIKER")] + Objrefmoniker = 0x8, + [NativeName("Name", "MKSYS_SESSIONMONIKER")] + Sessionmoniker = 0x9, + [NativeName("Name", "MKSYS_LUAMONIKER")] + Luamoniker = 0xA, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs new file mode 100644 index 0000000000..e1895d033c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPENDINGMSG")] + public enum TagPENDINGMSG : int + { + [Obsolete("Deprecated in favour of \"Cancelcall\"")] + [NativeName("Name", "PENDINGMSG_CANCELCALL")] + PendingmsgCancelcall = 0x0, + [Obsolete("Deprecated in favour of \"Waitnoprocess\"")] + [NativeName("Name", "PENDINGMSG_WAITNOPROCESS")] + PendingmsgWaitnoprocess = 0x1, + [Obsolete("Deprecated in favour of \"Waitdefprocess\"")] + [NativeName("Name", "PENDINGMSG_WAITDEFPROCESS")] + PendingmsgWaitdefprocess = 0x2, + [NativeName("Name", "PENDINGMSG_CANCELCALL")] + Cancelcall = 0x0, + [NativeName("Name", "PENDINGMSG_WAITNOPROCESS")] + Waitnoprocess = 0x1, + [NativeName("Name", "PENDINGMSG_WAITDEFPROCESS")] + Waitdefprocess = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs new file mode 100644 index 0000000000..7bb72d1832 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagPENDINGTYPE")] + public enum TagPENDINGTYPE : int + { + [Obsolete("Deprecated in favour of \"Toplevel\"")] + [NativeName("Name", "PENDINGTYPE_TOPLEVEL")] + PendingtypeToplevel = 0x1, + [Obsolete("Deprecated in favour of \"Nested\"")] + [NativeName("Name", "PENDINGTYPE_NESTED")] + PendingtypeNested = 0x2, + [NativeName("Name", "PENDINGTYPE_TOPLEVEL")] + Toplevel = 0x1, + [NativeName("Name", "PENDINGTYPE_NESTED")] + Nested = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs new file mode 100644 index 0000000000..9e14a0dbdf --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSERVERCALL")] + public enum TagSERVERCALL : int + { + [Obsolete("Deprecated in favour of \"Ishandled\"")] + [NativeName("Name", "SERVERCALL_ISHANDLED")] + ServercallIshandled = 0x0, + [Obsolete("Deprecated in favour of \"Rejected\"")] + [NativeName("Name", "SERVERCALL_REJECTED")] + ServercallRejected = 0x1, + [Obsolete("Deprecated in favour of \"Retrylater\"")] + [NativeName("Name", "SERVERCALL_RETRYLATER")] + ServercallRetrylater = 0x2, + [NativeName("Name", "SERVERCALL_ISHANDLED")] + Ishandled = 0x0, + [NativeName("Name", "SERVERCALL_REJECTED")] + Rejected = 0x1, + [NativeName("Name", "SERVERCALL_RETRYLATER")] + Retrylater = 0x2, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs new file mode 100644 index 0000000000..0055d18dde --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs @@ -0,0 +1,20 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagShutdownType")] + public enum TagShutdownType : int + { + [NativeName("Name", "IdleShutdown")] + IdleShutdown = 0x0, + [NativeName("Name", "ForcedShutdown")] + ForcedShutdown = 0x1, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs new file mode 100644 index 0000000000..5690053fe7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs @@ -0,0 +1,57 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Flags] + [NativeName("Name", "tagTYMED")] + public enum TagTYMED : int + { + [Obsolete("Deprecated in favour of \"Hglobal\"")] + [NativeName("Name", "TYMED_HGLOBAL")] + TymedHglobal = 0x1, + [Obsolete("Deprecated in favour of \"File\"")] + [NativeName("Name", "TYMED_FILE")] + TymedFile = 0x2, + [Obsolete("Deprecated in favour of \"Istream\"")] + [NativeName("Name", "TYMED_ISTREAM")] + TymedIstream = 0x4, + [Obsolete("Deprecated in favour of \"Istorage\"")] + [NativeName("Name", "TYMED_ISTORAGE")] + TymedIstorage = 0x8, + [Obsolete("Deprecated in favour of \"Gdi\"")] + [NativeName("Name", "TYMED_GDI")] + TymedGdi = 0x10, + [Obsolete("Deprecated in favour of \"Mfpict\"")] + [NativeName("Name", "TYMED_MFPICT")] + TymedMfpict = 0x20, + [Obsolete("Deprecated in favour of \"Enhmf\"")] + [NativeName("Name", "TYMED_ENHMF")] + TymedEnhmf = 0x40, + [Obsolete("Deprecated in favour of \"Null\"")] + [NativeName("Name", "TYMED_NULL")] + TymedNull = 0x0, + [NativeName("Name", "TYMED_HGLOBAL")] + Hglobal = 0x1, + [NativeName("Name", "TYMED_FILE")] + File = 0x2, + [NativeName("Name", "TYMED_ISTREAM")] + Istream = 0x4, + [NativeName("Name", "TYMED_ISTORAGE")] + Istorage = 0x8, + [NativeName("Name", "TYMED_GDI")] + Gdi = 0x10, + [NativeName("Name", "TYMED_MFPICT")] + Mfpict = 0x20, + [NativeName("Name", "TYMED_ENHMF")] + Enhmf = 0x40, + [NativeName("Name", "TYMED_NULL")] + Null = 0x0, + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs new file mode 100644 index 0000000000..76e6171726 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs @@ -0,0 +1,272 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class AdviseSink2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public static void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public static void OnViewChange(this ComPtr thisVtbl, uint dwAspect, int lindex) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwAspect, lindex); + } + + /// To be documented. + public static unsafe void OnRename(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmk); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkPtr); + } + } + + /// To be documented. + public static void OnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public static void OnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this); + } + + /// To be documented. + public static unsafe void OnLinkSrcChange(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmk); + } + + /// To be documented. + public static void OnLinkSrcChange(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkPtr); + } + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->OnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnRename(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static void OnLinkSrcChange(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->OnLinkSrcChange((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void OnLinkSrcChange(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnLinkSrcChange(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs new file mode 100644 index 0000000000..a47e792c01 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs @@ -0,0 +1,239 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class AdviseSinkVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public static void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public static void OnViewChange(this ComPtr thisVtbl, uint dwAspect, int lindex) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwAspect, lindex); + } + + /// To be documented. + public static unsafe void OnRename(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmk); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkPtr); + } + } + + /// To be documented. + public static void OnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public static void OnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this); + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnDataChange(ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->OnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void OnRename(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->OnRename(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ApartmentShutdownVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ApartmentShutdownVtblExtensions.gen.cs new file mode 100644 index 0000000000..3fc7230f01 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ApartmentShutdownVtblExtensions.gen.cs @@ -0,0 +1,128 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ApartmentShutdownVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static void OnUninitialize(this ComPtr thisVtbl, ulong ui64ApartmentIdentifier) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ui64ApartmentIdentifier); + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs new file mode 100644 index 0000000000..53bdfe1a70 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs @@ -0,0 +1,253 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000150-0000-0000-c000-000000000046")] + [NativeName("Name", "AsyncIAdviseSink")] + public unsafe partial struct AsyncIAdviseSink : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000150-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(AsyncIAdviseSink val) + => Unsafe.As(ref val); + + public AsyncIAdviseSink + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public readonly unsafe void BeginOnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public readonly void BeginOnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public readonly void FinishOnDataChange() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + } + + /// To be documented. + public readonly void BeginOnViewChange(uint dwAspect, int lindex) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dwAspect, lindex); + } + + /// To be documented. + public readonly void FinishOnViewChange() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public readonly unsafe void BeginOnRename(IMoniker* pmk) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmk); + } + + /// To be documented. + public readonly void BeginOnRename(ref IMoniker pmk) + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly void FinishOnRename() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + } + + /// To be documented. + public readonly void BeginOnSave() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this); + } + + /// To be documented. + public readonly void FinishOnSave() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + } + + /// To be documented. + public readonly void BeginOnClose() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this); + } + + /// To be documented. + public readonly void FinishOnClose() + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly void BeginOnRename(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->BeginOnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs new file mode 100644 index 0000000000..a60f6a3248 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs @@ -0,0 +1,288 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000151-0000-0000-c000-000000000046")] + [NativeName("Name", "AsyncIAdviseSink2")] + public unsafe partial struct AsyncIAdviseSink2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000151-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator AsyncIAdviseSink(AsyncIAdviseSink2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(AsyncIAdviseSink2 val) + => Unsafe.As(ref val); + + public AsyncIAdviseSink2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public readonly unsafe void BeginOnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public readonly void BeginOnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public readonly void FinishOnDataChange() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + } + + /// To be documented. + public readonly void BeginOnViewChange(uint dwAspect, int lindex) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dwAspect, lindex); + } + + /// To be documented. + public readonly void FinishOnViewChange() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public readonly unsafe void BeginOnRename(IMoniker* pmk) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmk); + } + + /// To be documented. + public readonly void BeginOnRename(ref IMoniker pmk) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly void FinishOnRename() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + } + + /// To be documented. + public readonly void BeginOnSave() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this); + } + + /// To be documented. + public readonly void FinishOnSave() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + } + + /// To be documented. + public readonly void BeginOnClose() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this); + } + + /// To be documented. + public readonly void FinishOnClose() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + } + + /// To be documented. + public readonly unsafe void BeginOnLinkSrcChange(IMoniker* pmk) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmk); + } + + /// To be documented. + public readonly void BeginOnLinkSrcChange(ref IMoniker pmk) + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly void FinishOnLinkSrcChange() + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this); + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly void BeginOnRename(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->BeginOnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly void BeginOnLinkSrcChange(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->BeginOnLinkSrcChange((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs new file mode 100644 index 0000000000..6bd6b99012 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs @@ -0,0 +1,314 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class AsyncIAdviseSink2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public static void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public static void FinishOnDataChange(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + } + + /// To be documented. + public static void BeginOnViewChange(this ComPtr thisVtbl, uint dwAspect, int lindex) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dwAspect, lindex); + } + + /// To be documented. + public static void FinishOnViewChange(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public static unsafe void BeginOnRename(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmk); + } + + /// To be documented. + public static void BeginOnRename(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmkPtr); + } + } + + /// To be documented. + public static void FinishOnRename(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + } + + /// To be documented. + public static void BeginOnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this); + } + + /// To be documented. + public static void FinishOnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + } + + /// To be documented. + public static void BeginOnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this); + } + + /// To be documented. + public static void FinishOnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + } + + /// To be documented. + public static unsafe void BeginOnLinkSrcChange(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmk); + } + + /// To be documented. + public static void BeginOnLinkSrcChange(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmkPtr); + } + } + + /// To be documented. + public static void FinishOnLinkSrcChange(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this); + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnDataChange(pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnDataChange(ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + public static void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnDataChange(ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static void BeginOnRename(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->BeginOnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void BeginOnRename(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnRename(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static void BeginOnLinkSrcChange(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->BeginOnLinkSrcChange((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void BeginOnLinkSrcChange(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnLinkSrcChange(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs new file mode 100644 index 0000000000..1cf957543d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs @@ -0,0 +1,274 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class AsyncIAdviseSinkVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public static void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = thisVtbl.Handle; + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public static void FinishOnDataChange(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + } + + /// To be documented. + public static void BeginOnViewChange(this ComPtr thisVtbl, uint dwAspect, int lindex) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dwAspect, lindex); + } + + /// To be documented. + public static void FinishOnViewChange(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public static unsafe void BeginOnRename(this ComPtr thisVtbl, IMoniker* pmk) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmk); + } + + /// To be documented. + public static void BeginOnRename(this ComPtr thisVtbl, ref IMoniker pmk) + { + var @this = thisVtbl.Handle; + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pmkPtr); + } + } + + /// To be documented. + public static void FinishOnRename(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this); + } + + /// To be documented. + public static void BeginOnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this); + } + + /// To be documented. + public static void FinishOnSave(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + } + + /// To be documented. + public static void BeginOnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this); + } + + /// To be documented. + public static void FinishOnClose(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this); + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnDataChange(pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnDataChange(ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + public static void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnDataChange(ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + public static void BeginOnRename(this ComPtr thisVtbl, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + @this->BeginOnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public static void BeginOnRename(this ComPtr thisVtbl, Span pmk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + @this->BeginOnRename(ref pmk.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs new file mode 100644 index 0000000000..c3d9b1aff1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs @@ -0,0 +1,602 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class BindCtxVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int RegisterObjectBound(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, punk); + return ret; + } + + /// To be documented. + public static int RegisterObjectBound(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, punkPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RevokeObjectBound(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, punk); + return ret; + } + + /// To be documented. + public static int RevokeObjectBound(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, punkPtr); + } + return ret; + } + + /// To be documented. + public static int ReleaseBoundObjects(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetBindOptions(this ComPtr thisVtbl, TagBINDOPTS* pbindopts) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindopts); + return ret; + } + + /// To be documented. + public static int SetBindOptions(this ComPtr thisVtbl, ref TagBINDOPTS pbindopts) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindoptsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetBindOptions(this ComPtr thisVtbl, TagBINDOPTS* pbindopts) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindopts); + return ret; + } + + /// To be documented. + public static int GetBindOptions(this ComPtr thisVtbl, ref TagBINDOPTS pbindopts) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindoptsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetRunningObjectTable(this ComPtr thisVtbl, IRunningObjectTable** pprot) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pprot); + return ret; + } + + /// To be documented. + public static unsafe int GetRunningObjectTable(this ComPtr thisVtbl, ref IRunningObjectTable* pprot) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IRunningObjectTable** pprotPtr = &pprot) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pprotPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, char* pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKey, punk); + return ret; + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, char* pszKey, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKey, punkPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, ref char pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punk); + } + return ret; + } + + /// To be documented. + public static int RegisterObjectParam(this ComPtr thisVtbl, ref char pszKey, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punkPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punk); + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public static int RegisterObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punkPtr); + } + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, char* pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKey, ppunk); + return ret; + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, char* pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppunkPtr = &ppunk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKey, ppunkPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, ref char pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunk); + } + return ret; + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, ref char pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + fixed (Silk.NET.Core.Native.IUnknown** ppunkPtr = &ppunk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunkPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunk); + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown** ppunkPtr = &ppunk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunkPtr); + } + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public static unsafe int EnumObjectParam(this ComPtr thisVtbl, IEnumString** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int EnumObjectParam(this ComPtr thisVtbl, ref IEnumString* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumString** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RevokeObjectParam(this ComPtr thisVtbl, char* pszKey) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pszKey); + return ret; + } + + /// To be documented. + public static int RevokeObjectParam(this ComPtr thisVtbl, ref char pszKey) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pszKeyPtr); + } + return ret; + } + + /// To be documented. + public static int RevokeObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pszKeyPtr); + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int RegisterObjectBound(this ComPtr thisVtbl, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RegisterObjectBound((Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public static int RegisterObjectBound(this ComPtr thisVtbl, Span punk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RegisterObjectBound(ref punk.GetPinnableReference()); + } + + /// To be documented. + public static int RevokeObjectBound(this ComPtr thisVtbl, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RevokeObjectBound((Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public static int RevokeObjectBound(this ComPtr thisVtbl, Span punk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RevokeObjectBound(ref punk.GetPinnableReference()); + } + + /// To be documented. + public static int SetBindOptions(this ComPtr thisVtbl, Span pbindopts) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetBindOptions(ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + public static int GetBindOptions(this ComPtr thisVtbl, Span pbindopts) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetBindOptions(ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + public static int GetRunningObjectTable(this ComPtr thisVtbl, ref ComPtr pprot) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetRunningObjectTable((IRunningObjectTable**) pprot.GetAddressOf()); + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, char* pszKey, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RegisterObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, char* pszKey, Span punk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RegisterObjectParam(pszKey, ref punk.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RegisterObjectParam(this ComPtr thisVtbl, Span pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RegisterObjectParam(ref pszKey.GetPinnableReference(), punk); + } + + /// To be documented. + public static int RegisterObjectParam(this ComPtr thisVtbl, ref char pszKey, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RegisterObjectParam(ref pszKey, (Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public static int RegisterObjectParam(this ComPtr thisVtbl, Span pszKey, Span punk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RegisterObjectParam(ref pszKey.GetPinnableReference(), ref punk.GetPinnableReference()); + } + + /// To be documented. + public static int RegisterObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RegisterObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public static int RegisterObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, Span punk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RegisterObjectParam(pszKey, ref punk.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, char* pszKey, ref ComPtr ppunk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown**) ppunk.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, Span pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetObjectParam(ref pszKey.GetPinnableReference(), ppunk); + } + + /// To be documented. + public static int GetObjectParam(this ComPtr thisVtbl, ref char pszKey, ref ComPtr ppunk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetObjectParam(ref pszKey, (Silk.NET.Core.Native.IUnknown**) ppunk.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetObjectParam(this ComPtr thisVtbl, Span pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetObjectParam(ref pszKey.GetPinnableReference(), ref ppunk); + } + + /// To be documented. + public static int GetObjectParam(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ref ComPtr ppunk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown**) ppunk.GetAddressOf()); + } + + /// To be documented. + public static int EnumObjectParam(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumObjectParam((IEnumString**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static int RevokeObjectParam(this ComPtr thisVtbl, Span pszKey) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RevokeObjectParam(ref pszKey.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/BlockingLockVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BlockingLockVtblExtensions.gen.cs new file mode 100644 index 0000000000..5e491178ab --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BlockingLockVtblExtensions.gen.cs @@ -0,0 +1,139 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class BlockingLockVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int Lock(this ComPtr thisVtbl, uint dwTimeout) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwTimeout); + return ret; + } + + /// To be documented. + public static int Unlock(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ClassActivatorVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ClassActivatorVtblExtensions.gen.cs new file mode 100644 index 0000000000..370dc581f5 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ClassActivatorVtblExtensions.gen.cs @@ -0,0 +1,313 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ClassActivatorVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, Guid* riid, void** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riid, ppv); + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, Guid* riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riid, ppvPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, ref Guid riid, void** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riidPtr, ppv); + } + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, ref Guid riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riidPtr, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, ref Guid rclsid, uint dwClassContext, uint locale, Guid* riid, void** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riid, ppv); + } + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, ref Guid rclsid, uint dwClassContext, uint locale, Guid* riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riid, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, ref Guid rclsid, uint dwClassContext, uint locale, ref Guid riid, void** ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riidPtr, ppv); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, ref Guid rclsid, uint dwClassContext, uint locale, ref Guid riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riidPtr, ppvPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, out ComPtr ppv) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppv = default; + return @this->GetClassObject(rclsid, dwClassContext, locale, SilkMarshal.GuidPtrOf(), (void**) ppv.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, Span riid, void** ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassObject(rclsid, dwClassContext, locale, ref riid.GetPinnableReference(), ppv); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale, Span riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassObject(rclsid, dwClassContext, locale, ref riid.GetPinnableReference(), ref ppv); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Span rclsid, uint dwClassContext, uint locale, Guid* riid, void** ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassObject(ref rclsid.GetPinnableReference(), dwClassContext, locale, riid, ppv); + } + + /// To be documented. + public static int GetClassObject(this ComPtr thisVtbl, ref Guid rclsid, uint dwClassContext, uint locale, out ComPtr ppv) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppv = default; + return @this->GetClassObject(ref rclsid, dwClassContext, locale, SilkMarshal.GuidPtrOf(), (void**) ppv.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Span rclsid, uint dwClassContext, uint locale, Guid* riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassObject(ref rclsid.GetPinnableReference(), dwClassContext, locale, riid, ref ppv); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Span rclsid, uint dwClassContext, uint locale, Span riid, void** ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassObject(ref rclsid.GetPinnableReference(), dwClassContext, locale, ref riid.GetPinnableReference(), ppv); + } + + /// To be documented. + public static unsafe int GetClassObject(this ComPtr thisVtbl, Span rclsid, uint dwClassContext, uint locale, Span riid, ref void* ppv) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassObject(ref rclsid.GetPinnableReference(), dwClassContext, locale, ref riid.GetPinnableReference(), ref ppv); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr GetClassObject(this ComPtr thisVtbl, Guid* rclsid, uint dwClassContext, uint locale) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetClassObject(rclsid, dwClassContext, locale, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr GetClassObject(this ComPtr thisVtbl, ref Guid rclsid, uint dwClassContext, uint locale) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetClassObject(ref rclsid, dwClassContext, locale, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs new file mode 100644 index 0000000000..ccb3dee971 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs @@ -0,0 +1,652 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class DataAdviseHolderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnection); + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnectionPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnection); + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnection); + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnection); + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnection); + } + } + } + return ret; + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int Unadvise(this ComPtr thisVtbl, uint dwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwConnection); + return ret; + } + + /// To be documented. + public static unsafe int EnumAdvise(this ComPtr thisVtbl, IEnumSTATDATA** ppenumAdvise) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, ppenumAdvise); + return ret; + } + + /// To be documented. + public static unsafe int EnumAdvise(this ComPtr thisVtbl, ref IEnumSTATDATA* ppenumAdvise) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATDATA** ppenumAdvisePtr = &ppenumAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, ppenumAdvisePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SendOnDataChange(this ComPtr thisVtbl, IDataObject* pDataObject, uint dwReserved, uint advf) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pDataObject, dwReserved, advf); + return ret; + } + + /// To be documented. + public static int SendOnDataChange(this ComPtr thisVtbl, ref IDataObject pDataObject, uint dwReserved, uint advf) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pDataObjectPtr, dwReserved, advf); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, pFetc, advf, pAdvise, ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, pFetc, advf, ref pAdvise.GetPinnableReference(), pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, ref pAdvise, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, pFetc, advf, ref pAdvise.GetPinnableReference(), ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, ref pAdvise, ref pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, ref pFetc.GetPinnableReference(), advf, pAdvise, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, ref pFetc.GetPinnableReference(), advf, pAdvise, ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, Span pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, ref pFetc.GetPinnableReference(), advf, ref pAdvise.GetPinnableReference(), pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, ref pAdvise, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, Span pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(pDataObject, ref pFetc.GetPinnableReference(), advf, ref pAdvise.GetPinnableReference(), ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, ref pAdvise, ref pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), pFetc, advf, pAdvise, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise(ref pDataObject, pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), pFetc, advf, pAdvise, ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise(ref pDataObject, pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), pFetc, advf, ref pAdvise.GetPinnableReference(), pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), pFetc, advf, ref pAdvise.GetPinnableReference(), ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), ref pFetc.GetPinnableReference(), advf, pAdvise, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise(ref pDataObject, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), ref pFetc.GetPinnableReference(), advf, pAdvise, ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Advise(ref pDataObject, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, Span pAdvise, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), ref pFetc.GetPinnableReference(), advf, ref pAdvise.GetPinnableReference(), pdwConnection); + } + + /// To be documented. + public static int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, Span pAdvise, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Advise(ref pDataObject.GetPinnableReference(), ref pFetc.GetPinnableReference(), advf, ref pAdvise.GetPinnableReference(), ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static int EnumAdvise(this ComPtr thisVtbl, ref ComPtr ppenumAdvise) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumAdvise((IEnumSTATDATA**) ppenumAdvise.GetAddressOf()); + } + + /// To be documented. + public static int SendOnDataChange(this ComPtr thisVtbl, ComPtr pDataObject, uint dwReserved, uint advf) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SendOnDataChange((IDataObject*) pDataObject.Handle, dwReserved, advf); + } + + /// To be documented. + public static int SendOnDataChange(this ComPtr thisVtbl, Span pDataObject, uint dwReserved, uint advf) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SendOnDataChange(ref pDataObject.GetPinnableReference(), dwReserved, advf); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs new file mode 100644 index 0000000000..fda2e68d3b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs @@ -0,0 +1,701 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class DataObjectVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmedium); + return ret; + } + + /// To be documented. + public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmediumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmedium); + } + return ret; + } + + /// To be documented. + public static int GetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + { + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmediumPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmedium); + return ret; + } + + /// To be documented. + public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmediumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDataHere(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmedium); + } + return ret; + } + + /// To be documented. + public static int GetDataHere(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmediumPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int QueryGetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetc); + return ret; + } + + /// To be documented. + public static int QueryGetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetcPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, TagFORMATETC* pformatectIn, TagFORMATETC* pformatetcOut) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOut); + return ret; + } + + /// To be documented. + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, TagFORMATETC* pformatectIn, ref TagFORMATETC pformatetcOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOutPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, ref TagFORMATETC pformatectIn, TagFORMATETC* pformatetcOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOut); + } + return ret; + } + + /// To be documented. + public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, ref TagFORMATETC pformatectIn, ref TagFORMATETC pformatetcOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + { + fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOutPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmedium, fRelease); + return ret; + } + + /// To be documented. + public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmediumPtr, fRelease); + } + return ret; + } + + /// To be documented. + public static unsafe int SetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmedium, fRelease); + } + return ret; + } + + /// To be documented. + public static int SetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmediumPtr, fRelease); + } + } + return ret; + } + + /// To be documented. + public static unsafe int EnumFormatEtc(this ComPtr thisVtbl, uint dwDirection, IEnumFORMATETC** ppenumFormatEtc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, dwDirection, ppenumFormatEtc); + return ret; + } + + /// To be documented. + public static unsafe int EnumFormatEtc(this ComPtr thisVtbl, uint dwDirection, ref IEnumFORMATETC* ppenumFormatEtc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumFORMATETC** ppenumFormatEtcPtr = &ppenumFormatEtc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, dwDirection, ppenumFormatEtcPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnection); + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnectionPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnection); + } + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnection); + } + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public static int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int DUnadvise(this ComPtr thisVtbl, uint dwConnection) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, dwConnection); + return ret; + } + + /// To be documented. + public static unsafe int EnumDAdvise(this ComPtr thisVtbl, IEnumSTATDATA** ppenumAdvise) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumAdvise); + return ret; + } + + /// To be documented. + public static unsafe int EnumDAdvise(this ComPtr thisVtbl, ref IEnumSTATDATA* ppenumAdvise) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATDATA** ppenumAdvisePtr = &ppenumAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumAdvisePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC* pformatetcIn, Span pmedium) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetData(pformatetcIn, ref pmedium.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetData(this ComPtr thisVtbl, Span pformatetcIn, TagSTGMEDIUM* pmedium) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetData(ref pformatetcIn.GetPinnableReference(), pmedium); + } + + /// To be documented. + public static int GetData(this ComPtr thisVtbl, Span pformatetcIn, Span pmedium) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetData(ref pformatetcIn.GetPinnableReference(), ref pmedium.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMATETC* pformatetc, Span pmedium) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDataHere(pformatetc, ref pmedium.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDataHere(this ComPtr thisVtbl, Span pformatetc, TagSTGMEDIUM* pmedium) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDataHere(ref pformatetc.GetPinnableReference(), pmedium); + } + + /// To be documented. + public static int GetDataHere(this ComPtr thisVtbl, Span pformatetc, Span pmedium) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDataHere(ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference()); + } + + /// To be documented. + public static int QueryGetData(this ComPtr thisVtbl, Span pformatetc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryGetData(ref pformatetc.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, TagFORMATETC* pformatectIn, Span pformatetcOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCanonicalFormatEtc(pformatectIn, ref pformatetcOut.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span pformatectIn, TagFORMATETC* pformatetcOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCanonicalFormatEtc(ref pformatectIn.GetPinnableReference(), pformatetcOut); + } + + /// To be documented. + public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span pformatectIn, Span pformatetcOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCanonicalFormatEtc(ref pformatectIn.GetPinnableReference(), ref pformatetcOut.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetData(pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + public static unsafe int SetData(this ComPtr thisVtbl, Span pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetData(ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + public static int SetData(this ComPtr thisVtbl, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetData(ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + public static int EnumFormatEtc(this ComPtr thisVtbl, uint dwDirection, ref ComPtr ppenumFormatEtc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumFormatEtc(dwDirection, (IEnumFORMATETC**) ppenumFormatEtc.GetAddressOf()); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->DAdvise(pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, pdwConnection); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(pformatetc, advf, pAdvSink, ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->DAdvise(pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, ref pdwConnection); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, Span pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(pformatetc, advf, ref pAdvSink.GetPinnableReference(), pdwConnection); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, Span pAdvSink, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(pformatetc, advf, ref pAdvSink.GetPinnableReference(), ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(ref pformatetc.GetPinnableReference(), advf, pAdvSink, pdwConnection); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->DAdvise(ref pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, pdwConnection); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, IAdviseSink* pAdvSink, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(ref pformatetc.GetPinnableReference(), advf, pAdvSink, ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->DAdvise(ref pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, ref pdwConnection); + } + + /// To be documented. + public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, Span pAdvSink, uint* pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(ref pformatetc.GetPinnableReference(), advf, ref pAdvSink.GetPinnableReference(), pdwConnection); + } + + /// To be documented. + public static int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, Span pAdvSink, Span pdwConnection) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DAdvise(ref pformatetc.GetPinnableReference(), advf, ref pAdvSink.GetPinnableReference(), ref pdwConnection.GetPinnableReference()); + } + + /// To be documented. + public static int EnumDAdvise(this ComPtr thisVtbl, ref ComPtr ppenumAdvise) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumDAdvise((IEnumSTATDATA**) ppenumAdvise.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DirectWriterLockVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DirectWriterLockVtblExtensions.gen.cs new file mode 100644 index 0000000000..df14bd8320 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DirectWriterLockVtblExtensions.gen.cs @@ -0,0 +1,148 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class DirectWriterLockVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int WaitForWriteAccess(this ComPtr thisVtbl, uint dwTimeout) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwTimeout); + return ret; + } + + /// To be documented. + public static int ReleaseWriteAccess(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static int HaveWriteAccess(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DummyHICONIncluderVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DummyHICONIncluderVtblExtensions.gen.cs new file mode 100644 index 0000000000..d2af42cf2d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DummyHICONIncluderVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class DummyHICONIncluderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Dummy(this ComPtr thisVtbl, void* h1, nint h2) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, h1, h2); + return ret; + } + + /// To be documented. + public static int Dummy(this ComPtr thisVtbl, ref T0 h1, nint h2) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* h1Ptr = &h1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, h1Ptr, h2); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int Dummy(this ComPtr thisVtbl, Span h1, nint h2) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Dummy(ref h1.GetPinnableReference(), h2); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs new file mode 100644 index 0000000000..c099f38f2c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumFORMATETCVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagFORMATETC* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumFORMATETC** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumFORMATETC* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumFORMATETC** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumFORMATETC**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumMonikerVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumMonikerVtblExtensions.gen.cs new file mode 100644 index 0000000000..68e545147f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumMonikerVtblExtensions.gen.cs @@ -0,0 +1,248 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumMonikerVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, IMoniker** rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, IMoniker** rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref IMoniker* rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumMoniker** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumMoniker* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumMoniker** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Next(celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, IMoniker** rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Next(celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumMoniker**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs new file mode 100644 index 0000000000..9861d5c09e --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumSTATDATAVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagSTATDATA* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagSTATDATA* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumSTATDATA** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumSTATDATA* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATDATA** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumSTATDATA**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATSTGVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATSTGVtblExtensions.gen.cs new file mode 100644 index 0000000000..9bc1b86627 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATSTGVtblExtensions.gen.cs @@ -0,0 +1,240 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class EnumSTATSTGVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATSTG* rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATSTG* rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref STATSTG rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATSTG* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref STATSTG rgelt, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATSTG* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IEnumSTATSTG** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IEnumSTATSTG* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATSTG* rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/FillLockBytesVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/FillLockBytesVtblExtensions.gen.cs new file mode 100644 index 0000000000..b0f9be5f29 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/FillLockBytesVtblExtensions.gen.cs @@ -0,0 +1,283 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class FillLockBytesVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public static unsafe int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public static int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public static unsafe int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public static int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static int SetFillSize(this ComPtr thisVtbl, ulong ulSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, ulSize); + return ret; + } + + /// To be documented. + public static int Terminate(this ComPtr thisVtbl, Silk.NET.Core.Bool32 bCanceled) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, bCanceled); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FillAppend(pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FillAppend(in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + public static int FillAppend(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FillAppend(in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FillAt(ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FillAt(ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + public static int FillAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->FillAt(ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs new file mode 100644 index 0000000000..8941d26d92 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "_FLAG_STGMEDIUM")] + public unsafe partial struct FlagStgmedium + { + public FlagStgmedium + ( + int? contextFlags = null, + int? fPassOwnership = null, + TagSTGMEDIUM? stgmed = null + ) : this() + { + if (contextFlags is not null) + { + ContextFlags = contextFlags.Value; + } + + if (fPassOwnership is not null) + { + FPassOwnership = fPassOwnership.Value; + } + + if (stgmed is not null) + { + Stgmed = stgmed.Value; + } + } + + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "ContextFlags")] + public int ContextFlags; + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "fPassOwnership")] + public int FPassOwnership; + + [NativeName("Type", "STGMEDIUM")] + [NativeName("Type.Name", "STGMEDIUM")] + [NativeName("Name", "Stgmed")] + public TagSTGMEDIUM Stgmed; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ForegroundTransferVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ForegroundTransferVtblExtensions.gen.cs new file mode 100644 index 0000000000..b0d916d7cf --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ForegroundTransferVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ForegroundTransferVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int AllowForegroundTransfer(this ComPtr thisVtbl, void* lpvReserved) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpvReserved); + return ret; + } + + /// To be documented. + public static int AllowForegroundTransfer(this ComPtr thisVtbl, ref T0 lpvReserved) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* lpvReservedPtr = &lpvReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpvReservedPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int AllowForegroundTransfer(this ComPtr thisVtbl, Span lpvReserved) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AllowForegroundTransfer(ref lpvReserved.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs new file mode 100644 index 0000000000..defebb3af9 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs @@ -0,0 +1,218 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000010f-0000-0000-c000-000000000046")] + [NativeName("Name", "IAdviseSink")] + public unsafe partial struct IAdviseSink : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000010f-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IAdviseSink val) + => Unsafe.As(ref val); + + public IAdviseSink + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public readonly unsafe void OnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public readonly void OnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public readonly void OnViewChange(uint dwAspect, int lindex) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwAspect, lindex); + } + + /// To be documented. + public readonly unsafe void OnRename(IMoniker* pmk) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmk); + } + + /// To be documented. + public readonly void OnRename(ref IMoniker pmk) + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly void OnSave() + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public readonly void OnClose() + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this); + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly void OnRename(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->OnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs new file mode 100644 index 0000000000..437246d37c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs @@ -0,0 +1,246 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000125-0000-0000-c000-000000000046")] + [NativeName("Name", "IAdviseSink2")] + public unsafe partial struct IAdviseSink2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000125-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IAdviseSink(IAdviseSink2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IAdviseSink2 val) + => Unsafe.As(ref val); + + public IAdviseSink2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + } + + /// To be documented. + public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + } + } + + /// To be documented. + public readonly unsafe void OnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + } + } + + /// To be documented. + public readonly void OnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + { + fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + } + } + } + + /// To be documented. + public readonly void OnViewChange(uint dwAspect, int lindex) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwAspect, lindex); + } + + /// To be documented. + public readonly unsafe void OnRename(IMoniker* pmk) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmk); + } + + /// To be documented. + public readonly void OnRename(ref IMoniker pmk) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly void OnSave() + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this); + } + + /// To be documented. + public readonly void OnClose() + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this); + } + + /// To be documented. + public readonly unsafe void OnLinkSrcChange(IMoniker* pmk) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmk); + } + + /// To be documented. + public readonly void OnLinkSrcChange(ref IMoniker pmk) + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + fixed (IMoniker* pmkPtr = &pmk) + { + ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkPtr); + } + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly void OnRename(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->OnRename((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly void OnLinkSrcChange(ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + @this->OnLinkSrcChange((IMoniker*) pmk.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IApartmentShutdown.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IApartmentShutdown.gen.cs new file mode 100644 index 0000000000..d814309da4 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IApartmentShutdown.gen.cs @@ -0,0 +1,139 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("a2f05a09-27a2-42b5-bc0e-ac163ef49d9b")] + [NativeName("Name", "IApartmentShutdown")] + public unsafe partial struct IApartmentShutdown : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a2f05a09-27a2-42b5-bc0e-ac163ef49d9b"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IApartmentShutdown val) + => Unsafe.As(ref val); + + public IApartmentShutdown + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly void OnUninitialize(ulong ui64ApartmentIdentifier) + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ui64ApartmentIdentifier); + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IApartmentShutdown*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs new file mode 100644 index 0000000000..0c3052fe82 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs @@ -0,0 +1,525 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000000e-0000-0000-c000-000000000046")] + [NativeName("Name", "IBindCtx")] + public unsafe partial struct IBindCtx : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000000e-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IBindCtx val) + => Unsafe.As(ref val); + + public IBindCtx + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int RegisterObjectBound(Silk.NET.Core.Native.IUnknown* punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, punk); + return ret; + } + + /// To be documented. + public readonly int RegisterObjectBound(ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, punkPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RevokeObjectBound(Silk.NET.Core.Native.IUnknown* punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, punk); + return ret; + } + + /// To be documented. + public readonly int RevokeObjectBound(ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, punkPtr); + } + return ret; + } + + /// To be documented. + public readonly int ReleaseBoundObjects() + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetBindOptions(TagBINDOPTS* pbindopts) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindopts); + return ret; + } + + /// To be documented. + public readonly int SetBindOptions(ref TagBINDOPTS pbindopts) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindoptsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetBindOptions(TagBINDOPTS* pbindopts) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindopts); + return ret; + } + + /// To be documented. + public readonly int GetBindOptions(ref TagBINDOPTS pbindopts) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindoptsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetRunningObjectTable(IRunningObjectTable** pprot) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pprot); + return ret; + } + + /// To be documented. + public readonly unsafe int GetRunningObjectTable(ref IRunningObjectTable* pprot) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IRunningObjectTable** pprotPtr = &pprot) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pprotPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RegisterObjectParam(char* pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKey, punk); + return ret; + } + + /// To be documented. + public readonly unsafe int RegisterObjectParam(char* pszKey, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKey, punkPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RegisterObjectParam(ref char pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punk); + } + return ret; + } + + /// To be documented. + public readonly int RegisterObjectParam(ref char pszKey, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punkPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RegisterObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, Silk.NET.Core.Native.IUnknown* punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punk); + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public readonly int RegisterObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ref Silk.NET.Core.Native.IUnknown punk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown* punkPtr = &punk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pszKeyPtr, punkPtr); + } + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectParam(char* pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKey, ppunk); + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectParam(char* pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppunkPtr = &ppunk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKey, ppunkPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectParam(ref char pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunk); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectParam(ref char pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + fixed (Silk.NET.Core.Native.IUnknown** ppunkPtr = &ppunk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunkPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, Silk.NET.Core.Native.IUnknown** ppunk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunk); + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ref Silk.NET.Core.Native.IUnknown* ppunk) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Native.IUnknown** ppunkPtr = &ppunk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pszKeyPtr, ppunkPtr); + } + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumObjectParam(IEnumString** ppenum) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumObjectParam(ref IEnumString* ppenum) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumString** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RevokeObjectParam(char* pszKey) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pszKey); + return ret; + } + + /// To be documented. + public readonly int RevokeObjectParam(ref char pszKey) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszKeyPtr = &pszKey) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pszKeyPtr); + } + return ret; + } + + /// To be documented. + public readonly int RevokeObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey) + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszKeyPtr = (byte*) SilkMarshal.StringToPtr(pszKey, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pszKeyPtr); + SilkMarshal.Free((nint)pszKeyPtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int RegisterObjectBound(ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RegisterObjectBound((Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public readonly int RevokeObjectBound(ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RevokeObjectBound((Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public readonly int GetRunningObjectTable(ref ComPtr pprot) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetRunningObjectTable((IRunningObjectTable**) pprot.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int RegisterObjectParam(char* pszKey, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RegisterObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public readonly int RegisterObjectParam(ref char pszKey, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RegisterObjectParam(ref pszKey, (Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public readonly int RegisterObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ComPtr punk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RegisterObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown*) punk.Handle); + } + + /// To be documented. + public readonly unsafe int GetObjectParam(char* pszKey, ref ComPtr ppunk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown**) ppunk.GetAddressOf()); + } + + /// To be documented. + public readonly int GetObjectParam(ref char pszKey, ref ComPtr ppunk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetObjectParam(ref pszKey, (Silk.NET.Core.Native.IUnknown**) ppunk.GetAddressOf()); + } + + /// To be documented. + public readonly int GetObjectParam([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszKey, ref ComPtr ppunk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetObjectParam(pszKey, (Silk.NET.Core.Native.IUnknown**) ppunk.GetAddressOf()); + } + + /// To be documented. + public readonly int EnumObjectParam(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumObjectParam((IEnumString**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IBlockingLock.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IBlockingLock.gen.cs new file mode 100644 index 0000000000..8b670cd620 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IBlockingLock.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("30f3d47a-6447-11d1-8e3c-00c04fb9386d")] + [NativeName("Name", "IBlockingLock")] + public unsafe partial struct IBlockingLock : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("30f3d47a-6447-11d1-8e3c-00c04fb9386d"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IBlockingLock val) + => Unsafe.As(ref val); + + public IBlockingLock + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int Lock(uint dwTimeout) + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwTimeout); + return ret; + } + + /// To be documented. + public readonly int Unlock() + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IBlockingLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IClassActivator.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IClassActivator.gen.cs new file mode 100644 index 0000000000..6bcd86d0b7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IClassActivator.gen.cs @@ -0,0 +1,276 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000140-0000-0000-c000-000000000046")] + [NativeName("Name", "IClassActivator")] + public unsafe partial struct IClassActivator : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000140-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IClassActivator val) + => Unsafe.As(ref val); + + public IClassActivator + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(Guid* rclsid, uint dwClassContext, uint locale, Guid* riid, void** ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riid, ppv); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(Guid* rclsid, uint dwClassContext, uint locale, Guid* riid, ref void* ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riid, ppvPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(Guid* rclsid, uint dwClassContext, uint locale, ref Guid riid, void** ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riidPtr, ppv); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(Guid* rclsid, uint dwClassContext, uint locale, ref Guid riid, ref void* ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, dwClassContext, locale, riidPtr, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(ref Guid rclsid, uint dwClassContext, uint locale, Guid* riid, void** ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riid, ppv); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(ref Guid rclsid, uint dwClassContext, uint locale, Guid* riid, ref void* ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riid, ppvPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(ref Guid rclsid, uint dwClassContext, uint locale, ref Guid riid, void** ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riidPtr, ppv); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassObject(ref Guid rclsid, uint dwClassContext, uint locale, ref Guid riid, ref void* ppv) + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvPtr = &ppv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, dwClassContext, locale, riidPtr, ppvPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetClassObject(Guid* rclsid, uint dwClassContext, uint locale, out ComPtr ppv) where TI0 : unmanaged, IComVtbl + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppv = default; + return @this->GetClassObject(rclsid, dwClassContext, locale, SilkMarshal.GuidPtrOf(), (void**) ppv.GetAddressOf()); + } + + /// To be documented. + public readonly int GetClassObject(ref Guid rclsid, uint dwClassContext, uint locale, out ComPtr ppv) where TI0 : unmanaged, IComVtbl + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppv = default; + return @this->GetClassObject(ref rclsid, dwClassContext, locale, SilkMarshal.GuidPtrOf(), (void**) ppv.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr GetClassObject(Guid* rclsid, uint dwClassContext, uint locale) where TI0 : unmanaged, IComVtbl + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetClassObject(rclsid, dwClassContext, locale, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr GetClassObject(ref Guid rclsid, uint dwClassContext, uint locale) where TI0 : unmanaged, IComVtbl + { + var @this = (IClassActivator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->GetClassObject(ref rclsid, dwClassContext, locale, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs new file mode 100644 index 0000000000..e648022145 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs @@ -0,0 +1,535 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000110-0000-0000-c000-000000000046")] + [NativeName("Name", "IDataAdviseHolder")] + public unsafe partial struct IDataAdviseHolder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000110-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IDataAdviseHolder val) + => Unsafe.As(ref val); + + public IDataAdviseHolder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnection); + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnectionPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnection); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnection); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnection); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnection); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + fixed (TagFORMATETC* pFetcPtr = &pFetc) + { + fixed (IAdviseSink* pAdvisePtr = &pAdvise) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int Unadvise(uint dwConnection) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwConnection); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumAdvise(IEnumSTATDATA** ppenumAdvise) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, ppenumAdvise); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumAdvise(ref IEnumSTATDATA* ppenumAdvise) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATDATA** ppenumAdvisePtr = &ppenumAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, ppenumAdvisePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SendOnDataChange(IDataObject* pDataObject, uint dwReserved, uint advf) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pDataObject, dwReserved, advf); + return ret; + } + + /// To be documented. + public readonly int SendOnDataChange(ref IDataObject pDataObject, uint dwReserved, uint advf) + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IDataObject* pDataObjectPtr = &pDataObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pDataObjectPtr, dwReserved, advf); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, ref pAdvise, pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, pFetc, advf, ref pAdvise, ref pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public readonly int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, ref pAdvise, pdwConnection); + } + + /// To be documented. + public readonly int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise((IDataObject*) pDataObject.Handle, ref pFetc, advf, ref pAdvise, ref pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise(ref pDataObject, pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise(ref pDataObject, pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise(ref pDataObject, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, pdwConnection); + } + + /// To be documented. + public readonly int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Advise(ref pDataObject, ref pFetc, advf, (IAdviseSink*) pAdvise.Handle, ref pdwConnection); + } + + /// To be documented. + public readonly int EnumAdvise(ref ComPtr ppenumAdvise) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumAdvise((IEnumSTATDATA**) ppenumAdvise.GetAddressOf()); + } + + /// To be documented. + public readonly int SendOnDataChange(ComPtr pDataObject, uint dwReserved, uint advf) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SendOnDataChange((IDataObject*) pDataObject.Handle, dwReserved, advf); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs new file mode 100644 index 0000000000..2713eab0a5 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs @@ -0,0 +1,552 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000010e-0000-0000-c000-000000000046")] + [NativeName("Name", "IDataObject")] + public unsafe partial struct IDataObject : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000010e-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IDataObject val) + => Unsafe.As(ref val); + + public IDataObject + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetData(TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmedium); + return ret; + } + + /// To be documented. + public readonly unsafe int GetData(TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmediumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetData(ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmedium); + } + return ret; + } + + /// To be documented. + public readonly int GetData(ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + { + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmediumPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataHere(TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmedium); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataHere(TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmediumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataHere(ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmedium); + } + return ret; + } + + /// To be documented. + public readonly int GetDataHere(ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmediumPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryGetData(TagFORMATETC* pformatetc) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetc); + return ret; + } + + /// To be documented. + public readonly int QueryGetData(ref TagFORMATETC pformatetc) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetcPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCanonicalFormatEtc(TagFORMATETC* pformatectIn, TagFORMATETC* pformatetcOut) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOut); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCanonicalFormatEtc(TagFORMATETC* pformatectIn, ref TagFORMATETC pformatetcOut) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOutPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCanonicalFormatEtc(ref TagFORMATETC pformatectIn, TagFORMATETC* pformatetcOut) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOut); + } + return ret; + } + + /// To be documented. + public readonly int GetCanonicalFormatEtc(ref TagFORMATETC pformatectIn, ref TagFORMATETC pformatetcOut) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + { + fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOutPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetData(TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmedium, fRelease); + return ret; + } + + /// To be documented. + public readonly unsafe int SetData(TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmediumPtr, fRelease); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetData(ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmedium, fRelease); + } + return ret; + } + + /// To be documented. + public readonly int SetData(ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmediumPtr, fRelease); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int EnumFormatEtc(uint dwDirection, IEnumFORMATETC** ppenumFormatEtc) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, dwDirection, ppenumFormatEtc); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumFormatEtc(uint dwDirection, ref IEnumFORMATETC* ppenumFormatEtc) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumFORMATETC** ppenumFormatEtcPtr = &ppenumFormatEtc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, dwDirection, ppenumFormatEtcPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnection); + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnectionPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnection); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnection); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnectionPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnection); + } + } + return ret; + } + + /// To be documented. + public readonly int DAdvise(ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + { + fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) + { + fixed (uint* pdwConnectionPtr = &pdwConnection) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnectionPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int DUnadvise(uint dwConnection) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, dwConnection); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumDAdvise(IEnumSTATDATA** ppenumAdvise) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumAdvise); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumDAdvise(ref IEnumSTATDATA* ppenumAdvise) + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATDATA** ppenumAdvisePtr = &ppenumAdvise) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, ppenumAdvisePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int EnumFormatEtc(uint dwDirection, ref ComPtr ppenumFormatEtc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumFormatEtc(dwDirection, (IEnumFORMATETC**) ppenumFormatEtc.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->DAdvise(pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, pdwConnection); + } + + /// To be documented. + public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->DAdvise(pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, ref pdwConnection); + } + + /// To be documented. + public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->DAdvise(ref pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, pdwConnection); + } + + /// To be documented. + public readonly int DAdvise(ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->DAdvise(ref pformatetc, advf, (IAdviseSink*) pAdvSink.Handle, ref pdwConnection); + } + + /// To be documented. + public readonly int EnumDAdvise(ref ComPtr ppenumAdvise) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumDAdvise((IEnumSTATDATA**) ppenumAdvise.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDirectWriterLock.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDirectWriterLock.gen.cs new file mode 100644 index 0000000000..eeb73c59fd --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDirectWriterLock.gen.cs @@ -0,0 +1,159 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0e6d4d92-6738-11cf-9608-00aa00680db4")] + [NativeName("Name", "IDirectWriterLock")] + public unsafe partial struct IDirectWriterLock : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0e6d4d92-6738-11cf-9608-00aa00680db4"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IDirectWriterLock val) + => Unsafe.As(ref val); + + public IDirectWriterLock + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int WaitForWriteAccess(uint dwTimeout) + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwTimeout); + return ret; + } + + /// To be documented. + public readonly int ReleaseWriteAccess() + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly int HaveWriteAccess() + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IDirectWriterLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDummyHICONIncluder.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDummyHICONIncluder.gen.cs new file mode 100644 index 0000000000..22032c0c6d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDummyHICONIncluder.gen.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("947990de-cc28-11d2-a0f7-00805f858fb1")] + [NativeName("Name", "IDummyHICONIncluder")] + public unsafe partial struct IDummyHICONIncluder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("947990de-cc28-11d2-a0f7-00805f858fb1"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IDummyHICONIncluder val) + => Unsafe.As(ref val); + + public IDummyHICONIncluder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Dummy(void* h1, nint h2) + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, h1, h2); + return ret; + } + + /// To be documented. + public readonly int Dummy(ref T0 h1, nint h2) where T0 : unmanaged + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* h1Ptr = &h1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, h1Ptr, h2); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IDummyHICONIncluder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs new file mode 100644 index 0000000000..61e606981c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000103-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumFORMATETC")] + public unsafe partial struct IEnumFORMATETC : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000103-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumFORMATETC val) + => Unsafe.As(ref val); + + public IEnumFORMATETC + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagFORMATETC* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumFORMATETC** ppenum) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumFORMATETC* ppenum) + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumFORMATETC** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumFORMATETC**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumMoniker.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumMoniker.gen.cs new file mode 100644 index 0000000000..a007635c4a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumMoniker.gen.cs @@ -0,0 +1,243 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000102-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumMoniker")] + public unsafe partial struct IEnumMoniker : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000102-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumMoniker val) + => Unsafe.As(ref val); + + public IEnumMoniker + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, IMoniker** rgelt, uint* pceltFetched) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, IMoniker** rgelt, ref uint pceltFetched) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref IMoniker* rgelt, uint* pceltFetched) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref IMoniker* rgelt, ref uint pceltFetched) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumMoniker** ppenum) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumMoniker* ppenum) + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumMoniker** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Next(celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + public readonly int Next(uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Next(celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumMoniker**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs new file mode 100644 index 0000000000..cff14c9291 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000105-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumSTATDATA")] + public unsafe partial struct IEnumSTATDATA : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000105-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumSTATDATA val) + => Unsafe.As(ref val); + + public IEnumSTATDATA + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagSTATDATA* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagSTATDATA* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumSTATDATA** ppenum) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumSTATDATA* ppenum) + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATDATA** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumSTATDATA**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATSTG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATSTG.gen.cs new file mode 100644 index 0000000000..490639c754 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATSTG.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000000d-0000-0000-c000-000000000046")] + [NativeName("Name", "IEnumSTATSTG")] + public unsafe partial struct IEnumSTATSTG : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000000d-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IEnumSTATSTG val) + => Unsafe.As(ref val); + + public IEnumSTATSTG + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, STATSTG* rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, STATSTG* rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref STATSTG rgelt, uint* pceltFetched) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATSTG* rgeltPtr = &rgelt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref STATSTG rgelt, ref uint pceltFetched) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATSTG* rgeltPtr = &rgelt) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IEnumSTATSTG** ppenum) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IEnumSTATSTG* ppenum) + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IEnumSTATSTG*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IFillLockBytes.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IFillLockBytes.gen.cs new file mode 100644 index 0000000000..6fbc70d09d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IFillLockBytes.gen.cs @@ -0,0 +1,246 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("99caf010-415e-11cf-8814-00aa00b569f5")] + [NativeName("Name", "IFillLockBytes")] + public unsafe partial struct IFillLockBytes : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("99caf010-415e-11cf-8814-00aa00b569f5"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IFillLockBytes val) + => Unsafe.As(ref val); + + public IFillLockBytes + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int FillAppend([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public readonly unsafe int FillAppend([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FillAppend([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly int FillAppend([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int FillAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public readonly unsafe int FillAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int FillAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly int FillAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int SetFillSize(ulong ulSize) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, ulSize); + return ret; + } + + /// To be documented. + public readonly int Terminate(Silk.NET.Core.Bool32 bCanceled) + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, bCanceled); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IFillLockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IForegroundTransfer.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IForegroundTransfer.gen.cs new file mode 100644 index 0000000000..7d247e72a1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IForegroundTransfer.gen.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000145-0000-0000-c000-000000000046")] + [NativeName("Name", "IForegroundTransfer")] + public unsafe partial struct IForegroundTransfer : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000145-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IForegroundTransfer val) + => Unsafe.As(ref val); + + public IForegroundTransfer + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int AllowForegroundTransfer(void* lpvReserved) + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpvReserved); + return ret; + } + + /// To be documented. + public readonly int AllowForegroundTransfer(ref T0 lpvReserved) where T0 : unmanaged + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* lpvReservedPtr = &lpvReserved) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpvReservedPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IForegroundTransfer*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IInitializeSpy.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IInitializeSpy.gen.cs new file mode 100644 index 0000000000..560fcca28d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IInitializeSpy.gen.cs @@ -0,0 +1,168 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000034-0000-0000-c000-000000000046")] + [NativeName("Name", "IInitializeSpy")] + public unsafe partial struct IInitializeSpy : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000034-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IInitializeSpy val) + => Unsafe.As(ref val); + + public IInitializeSpy + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int PreInitialize(uint dwCoInit, uint dwCurThreadAptRefs) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCoInit, dwCurThreadAptRefs); + return ret; + } + + /// To be documented. + public readonly int PostInitialize(int hrCoInit, uint dwCoInit, uint dwNewThreadAptRefs) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, hrCoInit, dwCoInit, dwNewThreadAptRefs); + return ret; + } + + /// To be documented. + public readonly int PreUninitialize(uint dwCurThreadAptRefs) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dwCurThreadAptRefs); + return ret; + } + + /// To be documented. + public readonly int PostUninitialize(uint dwNewThreadAptRefs) + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwNewThreadAptRefs); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IInitializeSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs new file mode 100644 index 0000000000..a2421b60b1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs @@ -0,0 +1,232 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0e6d4d90-6738-11cf-9608-00aa00680db4")] + [NativeName("Name", "ILayoutStorage")] + public unsafe partial struct ILayoutStorage : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0e6d4d90-6738-11cf-9608-00aa00680db4"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ILayoutStorage val) + => Unsafe.As(ref val); + + public ILayoutStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int LayoutScript(TagStorageLayout* pStorageLayout, uint nEntries, uint glfInterleavedFlag) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayout, nEntries, glfInterleavedFlag); + return ret; + } + + /// To be documented. + public readonly int LayoutScript(ref TagStorageLayout pStorageLayout, uint nEntries, uint glfInterleavedFlag) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (TagStorageLayout* pStorageLayoutPtr = &pStorageLayout) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayoutPtr, nEntries, glfInterleavedFlag); + } + return ret; + } + + /// To be documented. + public readonly int BeginMonitor() + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly int EndMonitor() + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int ReLayoutDocfile(char* pwcsNewDfName) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNewDfName); + return ret; + } + + /// To be documented. + public readonly int ReLayoutDocfile(ref char pwcsNewDfName) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNewDfNamePtr = &pwcsNewDfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNewDfNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int ReLayoutDocfile([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewDfName) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNewDfNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewDfName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNewDfNamePtr); + SilkMarshal.Free((nint)pwcsNewDfNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int ReLayoutDocfileOnILockBytes(ILockBytes* pILockBytes) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pILockBytes); + return ret; + } + + /// To be documented. + public readonly int ReLayoutDocfileOnILockBytes(ref ILockBytes pILockBytes) + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ILockBytes* pILockBytesPtr = &pILockBytes) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pILockBytesPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int ReLayoutDocfileOnILockBytes(ComPtr pILockBytes) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ReLayoutDocfileOnILockBytes((ILockBytes*) pILockBytes.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ILockBytes.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ILockBytes.gen.cs new file mode 100644 index 0000000000..eb32aeb6c7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ILockBytes.gen.cs @@ -0,0 +1,285 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000000a-0000-0000-c000-000000000046")] + [NativeName("Name", "ILockBytes")] + public unsafe partial struct ILockBytes : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000000a-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ILockBytes val) + => Unsafe.As(ref val); + + public ILockBytes + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int ReadAt(ulong ulOffset, void* pv, uint cb, uint* pcbRead) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pv, cb, pcbRead); + return ret; + } + + /// To be documented. + public readonly unsafe int ReadAt(ulong ulOffset, void* pv, uint cb, ref uint pcbRead) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pv, cb, pcbReadPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ReadAt(ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pvPtr, cb, pcbRead); + } + return ret; + } + + /// To be documented. + public readonly int ReadAt(ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pvPtr, cb, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly int WriteAt(ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Flush() + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly int SetSize(ulong cb) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cb); + return ret; + } + + /// To be documented. + public readonly int LockRegion(ulong libOffset, ulong cb, uint dwLockType) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public readonly int UnlockRegion(ulong libOffset, ulong cb, uint dwLockType) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public readonly unsafe int Stat(STATSTG* pstatstg, uint grfStatFlag) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pstatstg, grfStatFlag); + return ret; + } + + /// To be documented. + public readonly int Stat(ref STATSTG pstatstg, uint grfStatFlag) + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATSTG* pstatstgPtr = &pstatstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pstatstgPtr, grfStatFlag); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ILockBytes*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IMallocSpy.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMallocSpy.gen.cs new file mode 100644 index 0000000000..b954c2e181 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMallocSpy.gen.cs @@ -0,0 +1,345 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000001d-0000-0000-c000-000000000046")] + [NativeName("Name", "IMallocSpy")] + public unsafe partial struct IMallocSpy : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000001d-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IMallocSpy val) + => Unsafe.As(ref val); + + public IMallocSpy + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly nuint PreAlloc(nuint cbRequest) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + nuint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cbRequest); + return ret; + } + + /// To be documented. + public readonly unsafe void* PostAlloc(void* pActual) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pActual); + return ret; + } + + /// To be documented. + public readonly unsafe void* PostAlloc(ref T0 pActual) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + fixed (void* pActualPtr = &pActual) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe void* PreFree(void* pRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pRequest, fSpyed); + return ret; + } + + /// To be documented. + public readonly unsafe void* PreFree(ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public readonly void PostFree(Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, fSpyed); + } + + /// To be documented. + public readonly unsafe nuint PreRealloc(void* pRequest, nuint cbRequest, void** ppNewRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + nuint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequest, cbRequest, ppNewRequest, fSpyed); + return ret; + } + + /// To be documented. + public readonly unsafe nuint PreRealloc(void* pRequest, nuint cbRequest, ref void* ppNewRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + nuint ret = default; + fixed (void** ppNewRequestPtr = &ppNewRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequest, cbRequest, ppNewRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public readonly unsafe nuint PreRealloc(ref T0 pRequest, nuint cbRequest, void** ppNewRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + nuint ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequestPtr, cbRequest, ppNewRequest, fSpyed); + } + return ret; + } + + /// To be documented. + public readonly unsafe nuint PreRealloc(ref T0 pRequest, nuint cbRequest, ref void* ppNewRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + nuint ret = default; + fixed (void* pRequestPtr = &pRequest) + { + fixed (void** ppNewRequestPtr = &ppNewRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequestPtr, cbRequest, ppNewRequestPtr, fSpyed); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe void* PostRealloc(void* pActual, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pActual, fSpyed); + return ret; + } + + /// To be documented. + public readonly unsafe void* PostRealloc(ref T0 pActual, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + fixed (void* pActualPtr = &pActual) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pActualPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public readonly unsafe void* PreGetSize(void* pRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pRequest, fSpyed); + return ret; + } + + /// To be documented. + public readonly unsafe void* PreGetSize(ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public readonly nuint PostGetSize(nuint cbActual, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + nuint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, cbActual, fSpyed); + return ret; + } + + /// To be documented. + public readonly unsafe void* PreDidAlloc(void* pRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pRequest, fSpyed); + return ret; + } + + /// To be documented. + public readonly unsafe void* PreDidAlloc(ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + void* ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public readonly unsafe int PostDidAlloc(void* pRequest, Silk.NET.Core.Bool32 fSpyed, int fActual) + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pRequest, fSpyed, fActual); + return ret; + } + + /// To be documented. + public readonly int PostDidAlloc(ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed, int fActual) where T0 : unmanaged + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pRequestPtr, fSpyed, fActual); + } + return ret; + } + + /// To be documented. + public readonly void PreHeapMinimize() + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this); + } + + /// To be documented. + public readonly void PostHeapMinimize() + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this); + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IMallocSpy*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs new file mode 100644 index 0000000000..9f33d18003 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs @@ -0,0 +1,222 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000016-0000-0000-c000-000000000046")] + [NativeName("Name", "IMessageFilter")] + public unsafe partial struct IMessageFilter : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000016-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IMessageFilter val) + => Unsafe.As(ref val); + + public IMessageFilter + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe uint HandleInComingCall(uint dwCallType, void* htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); + return ret; + } + + /// To be documented. + public readonly unsafe uint HandleInComingCall(uint dwCallType, void* htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe uint HandleInComingCall(uint dwCallType, ref T0 htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) where T0 : unmanaged + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + fixed (void* htaskCallerPtr = &htaskCaller) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfo); + } + return ret; + } + + /// To be documented. + public readonly uint HandleInComingCall(uint dwCallType, ref T0 htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) where T0 : unmanaged + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + fixed (void* htaskCallerPtr = &htaskCaller) + { + fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe uint RetryRejectedCall(void* htaskCallee, uint dwTickCount, uint dwRejectType) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, htaskCallee, dwTickCount, dwRejectType); + return ret; + } + + /// To be documented. + public readonly uint RetryRejectedCall(ref T0 htaskCallee, uint dwTickCount, uint dwRejectType) where T0 : unmanaged + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + fixed (void* htaskCalleePtr = &htaskCallee) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, htaskCalleePtr, dwTickCount, dwRejectType); + } + return ret; + } + + /// To be documented. + public readonly unsafe uint MessagePending(void* htaskCallee, uint dwTickCount, uint dwPendingType) + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, htaskCallee, dwTickCount, dwPendingType); + return ret; + } + + /// To be documented. + public readonly uint MessagePending(ref T0 htaskCallee, uint dwTickCount, uint dwPendingType) where T0 : unmanaged + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + fixed (void* htaskCalleePtr = &htaskCallee) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, htaskCalleePtr, dwTickCount, dwPendingType); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IMoniker.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMoniker.gen.cs new file mode 100644 index 0000000000..26232a03cb --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMoniker.gen.cs @@ -0,0 +1,3184 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000000f-0000-0000-c000-000000000046")] + [NativeName("Name", "IMoniker")] + public unsafe partial struct IMoniker : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000000f-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IPersistStream(IMoniker val) + => Unsafe.As(ref val); + + public static implicit operator IPersist(IMoniker val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IMoniker val) + => Unsafe.As(ref val); + + public IMoniker + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Load(Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public readonly int Load(ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Save(Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public readonly int Save(ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeMax(ulong* pcbSize) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSize); + return ret; + } + + /// To be documented. + public readonly int GetSizeMax(ref ulong pcbSize) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResult, ppvResult); + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResult, ppvResultPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResultPtr, ppvResult); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResultPtr, ppvResultPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResult, ppvResult); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResult, ppvResultPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResultPtr, ppvResult); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResultPtr, ppvResultPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResult, ppvResult); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResult, ppvResultPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResultPtr, ppvResult); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResultPtr, ppvResultPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResult, ppvResult); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResult, ppvResultPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResultPtr, ppvResult); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResultPtr, ppvResultPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riid, ppvObj); + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riid, ppvObjPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riidPtr, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riidPtr, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riid, ppvObj); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riid, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riidPtr, ppvObj); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riidPtr, ppvObjPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced); + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeft, ppmkReducedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(IBindCtx* pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeftPtr, ppmkReduced); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(IBindCtx* pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeftPtr, ppmkReducedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeft, ppmkReduced); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeft, ppmkReducedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeftPtr, ppmkReduced); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeftPtr, ppmkReducedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ComposeWith(IMoniker* pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, IMoniker** ppmkComposite) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRight, fOnlyIfNotGeneric, ppmkComposite); + return ret; + } + + /// To be documented. + public readonly unsafe int ComposeWith(IMoniker* pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkCompositePtr = &ppmkComposite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRight, fOnlyIfNotGeneric, ppmkCompositePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ComposeWith(ref IMoniker pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, IMoniker** ppmkComposite) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkRightPtr = &pmkRight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRightPtr, fOnlyIfNotGeneric, ppmkComposite); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ComposeWith(ref IMoniker pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkRightPtr = &pmkRight) + { + fixed (IMoniker** ppmkCompositePtr = &ppmkComposite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRightPtr, fOnlyIfNotGeneric, ppmkCompositePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Enum(Silk.NET.Core.Bool32 fForward, IEnumMoniker** ppenumMoniker) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, fForward, ppenumMoniker); + return ret; + } + + /// To be documented. + public readonly unsafe int Enum(Silk.NET.Core.Bool32 fForward, ref IEnumMoniker* ppenumMoniker) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumMoniker** ppenumMonikerPtr = &ppenumMoniker) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, fForward, ppenumMonikerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsEqual(IMoniker* pmkOtherMoniker) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmkOtherMoniker); + return ret; + } + + /// To be documented. + public readonly int IsEqual(ref IMoniker pmkOtherMoniker) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkOtherMonikerPtr = &pmkOtherMoniker) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmkOtherMonikerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Hash(uint* pdwHash) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pdwHash); + return ret; + } + + /// To be documented. + public readonly int Hash(ref uint pdwHash) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwHashPtr = &pdwHash) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pdwHashPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeft, pmkNewlyRunning); + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(IBindCtx* pbc, IMoniker* pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeft, pmkNewlyRunningPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(IBindCtx* pbc, ref IMoniker pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeftPtr, pmkNewlyRunning); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(IBindCtx* pbc, ref IMoniker pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeftPtr, pmkNewlyRunningPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(ref IBindCtx pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeft, pmkNewlyRunning); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(ref IBindCtx pbc, IMoniker* pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeft, pmkNewlyRunningPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(ref IBindCtx pbc, ref IMoniker pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeftPtr, pmkNewlyRunning); + } + } + return ret; + } + + /// To be documented. + public readonly int IsRunning(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeftPtr, pmkNewlyRunningPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(IBindCtx* pbc, IMoniker* pmkToLeft, Filetime* pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeft, pFileTime); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(IBindCtx* pbc, IMoniker* pmkToLeft, ref Filetime pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeft, pFileTimePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(IBindCtx* pbc, ref IMoniker pmkToLeft, Filetime* pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeftPtr, pFileTime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(IBindCtx* pbc, ref IMoniker pmkToLeft, ref Filetime pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeftPtr, pFileTimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ref IBindCtx pbc, IMoniker* pmkToLeft, Filetime* pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeft, pFileTime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ref IBindCtx pbc, IMoniker* pmkToLeft, ref Filetime pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeft, pFileTimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ref IBindCtx pbc, ref IMoniker pmkToLeft, Filetime* pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeftPtr, pFileTime); + } + } + return ret; + } + + /// To be documented. + public readonly int GetTimeOfLastChange(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Filetime pFileTime) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeftPtr, pFileTimePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Inverse(IMoniker** ppmk) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, ppmk); + return ret; + } + + /// To be documented. + public readonly unsafe int Inverse(ref IMoniker* ppmk) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkPtr = &ppmk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, ppmkPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CommonPrefixWith(IMoniker* pmkOther, IMoniker** ppmkPrefix) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOther, ppmkPrefix); + return ret; + } + + /// To be documented. + public readonly unsafe int CommonPrefixWith(IMoniker* pmkOther, ref IMoniker* ppmkPrefix) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkPrefixPtr = &ppmkPrefix) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOther, ppmkPrefixPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CommonPrefixWith(ref IMoniker pmkOther, IMoniker** ppmkPrefix) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOtherPtr, ppmkPrefix); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CommonPrefixWith(ref IMoniker pmkOther, ref IMoniker* ppmkPrefix) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + fixed (IMoniker** ppmkPrefixPtr = &ppmkPrefix) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOtherPtr, ppmkPrefixPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RelativePathTo(IMoniker* pmkOther, IMoniker** ppmkRelPath) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOther, ppmkRelPath); + return ret; + } + + /// To be documented. + public readonly unsafe int RelativePathTo(IMoniker* pmkOther, ref IMoniker* ppmkRelPath) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkRelPathPtr = &ppmkRelPath) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOther, ppmkRelPathPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RelativePathTo(ref IMoniker pmkOther, IMoniker** ppmkRelPath) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOtherPtr, ppmkRelPath); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RelativePathTo(ref IMoniker pmkOther, ref IMoniker* ppmkRelPath) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + fixed (IMoniker** ppmkRelPathPtr = &ppmkRelPath) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOtherPtr, ppmkRelPathPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, char** ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeft, ppszDisplayName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, ref char* ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeft, ppszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, char** ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeftPtr, ppszDisplayName); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, ref char* ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeftPtr, ppszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, char** ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeft, ppszDisplayName); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, ref char* ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeft, ppszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char** ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeftPtr, ppszDisplayName); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char* ppszDisplayName) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeftPtr, ppszDisplayNamePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOut); + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOutPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOut); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOut); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEaten, ppmkOut); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEaten, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsSystemMoniker(uint* pdwMksys) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pdwMksys); + return ret; + } + + /// To be documented. + public readonly int IsSystemMoniker(ref uint pdwMksys) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwMksysPtr = &pdwMksys) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pdwMksysPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Load(ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public readonly int Save(ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public readonly int BindToObject(ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindToObject(ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + public readonly unsafe int BindToObject(ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + public readonly unsafe int BindToObject(ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + public readonly int BindToObject(ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindToObject(ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + public readonly unsafe int BindToObject(ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + public readonly unsafe int BindToObject(ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + public readonly int BindToObject(ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + public readonly unsafe int BindToObject(ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + public readonly int BindToObject(ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject(ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public readonly int BindToStorage(ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public readonly int BindToStorage(ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + public readonly int BindToStorage(ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + public readonly unsafe int BindToStorage(ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public readonly int BindToStorage(ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage(ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public readonly int Reduce(ComPtr pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Reduce(ComPtr pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref IMoniker* ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), ref ppmkReduced); + } + + /// To be documented. + public readonly unsafe int Reduce(ComPtr pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, ref ppmkToLeft, (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Reduce(ComPtr pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, ref ppmkToLeft, ref ppmkReduced); + } + + /// To be documented. + public readonly int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce(ref pbc, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref IMoniker* ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce(ref pbc, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), ref ppmkReduced); + } + + /// To be documented. + public readonly unsafe int Reduce(ref IBindCtx pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Reduce(ref pbc, dwReduceHowFar, ref ppmkToLeft, (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public readonly int ComposeWith(ComPtr pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref ComPtr ppmkComposite) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ComposeWith((IMoniker*) pmkRight.Handle, fOnlyIfNotGeneric, (IMoniker**) ppmkComposite.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ComposeWith(ComPtr pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ComposeWith((IMoniker*) pmkRight.Handle, fOnlyIfNotGeneric, ref ppmkComposite); + } + + /// To be documented. + public readonly int ComposeWith(ref IMoniker pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref ComPtr ppmkComposite) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ComposeWith(ref pmkRight, fOnlyIfNotGeneric, (IMoniker**) ppmkComposite.GetAddressOf()); + } + + /// To be documented. + public readonly int Enum(Silk.NET.Core.Bool32 fForward, ref ComPtr ppenumMoniker) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Enum(fForward, (IEnumMoniker**) ppenumMoniker.GetAddressOf()); + } + + /// To be documented. + public readonly int IsEqual(ComPtr pmkOtherMoniker) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsEqual((IMoniker*) pmkOtherMoniker.Handle); + } + + /// To be documented. + public readonly int IsRunning(ComPtr pbc, ComPtr pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public readonly int IsRunning(ComPtr pbc, ComPtr pmkToLeft, ref IMoniker pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pmkNewlyRunning); + } + + /// To be documented. + public readonly int IsRunning(ComPtr pbc, ref IMoniker pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, ref pmkToLeft, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public readonly int IsRunning(ComPtr pbc, ref IMoniker pmkToLeft, ref IMoniker pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pmkNewlyRunning); + } + + /// To be documented. + public readonly int IsRunning(ref IBindCtx pbc, ComPtr pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning(ref pbc, (IMoniker*) pmkToLeft.Handle, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public readonly int IsRunning(ref IBindCtx pbc, ComPtr pmkToLeft, ref IMoniker pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pmkNewlyRunning); + } + + /// To be documented. + public readonly int IsRunning(ref IBindCtx pbc, ref IMoniker pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning(ref pbc, ref pmkToLeft, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ComPtr pbc, ComPtr pmkToLeft, Filetime* pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pFileTime); + } + + /// To be documented. + public readonly int GetTimeOfLastChange(ComPtr pbc, ComPtr pmkToLeft, ref Filetime pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pFileTime); + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ComPtr pbc, ref IMoniker pmkToLeft, Filetime* pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, ref pmkToLeft, pFileTime); + } + + /// To be documented. + public readonly int GetTimeOfLastChange(ComPtr pbc, ref IMoniker pmkToLeft, ref Filetime pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pFileTime); + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ref IBindCtx pbc, ComPtr pmkToLeft, Filetime* pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange(ref pbc, (IMoniker*) pmkToLeft.Handle, pFileTime); + } + + /// To be documented. + public readonly int GetTimeOfLastChange(ref IBindCtx pbc, ComPtr pmkToLeft, ref Filetime pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pFileTime); + } + + /// To be documented. + public readonly int Inverse(ref ComPtr ppmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Inverse((IMoniker**) ppmk.GetAddressOf()); + } + + /// To be documented. + public readonly int CommonPrefixWith(ComPtr pmkOther, ref ComPtr ppmkPrefix) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CommonPrefixWith((IMoniker*) pmkOther.Handle, (IMoniker**) ppmkPrefix.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CommonPrefixWith(ComPtr pmkOther, ref IMoniker* ppmkPrefix) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CommonPrefixWith((IMoniker*) pmkOther.Handle, ref ppmkPrefix); + } + + /// To be documented. + public readonly int CommonPrefixWith(ref IMoniker pmkOther, ref ComPtr ppmkPrefix) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CommonPrefixWith(ref pmkOther, (IMoniker**) ppmkPrefix.GetAddressOf()); + } + + /// To be documented. + public readonly int RelativePathTo(ComPtr pmkOther, ref ComPtr ppmkRelPath) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RelativePathTo((IMoniker*) pmkOther.Handle, (IMoniker**) ppmkRelPath.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int RelativePathTo(ComPtr pmkOther, ref IMoniker* ppmkRelPath) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RelativePathTo((IMoniker*) pmkOther.Handle, ref ppmkRelPath); + } + + /// To be documented. + public readonly int RelativePathTo(ref IMoniker pmkOther, ref ComPtr ppmkRelPath) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->RelativePathTo(ref pmkOther, (IMoniker**) ppmkRelPath.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetDisplayName(IBindCtx* pbc, IMoniker* pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(pbc, pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ComPtr pbc, ComPtr pmkToLeft, char** ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ppszDisplayName); + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ComPtr pbc, ComPtr pmkToLeft, ref char* ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref ppszDisplayName); + } + + /// To be documented. + public readonly unsafe int GetDisplayName(IBindCtx* pbc, ref IMoniker pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(pbc, ref pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, char** ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ppszDisplayName); + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, ref char* ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref ppszDisplayName); + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, IMoniker* pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(ref pbc, pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, char** ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ppszDisplayName); + } + + /// To be documented. + public readonly unsafe int GetDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, ref char* ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref ppszDisplayName); + } + + /// To be documented. + public readonly int GetDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(ref pbc, ref pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly int ParseDisplayName(ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToObject(ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToObject(ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToObject(ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToObject(ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToStorage(ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToStorage(ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToStorage(ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr BindToStorage(ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl + { + var @this = (IMoniker*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IOplockStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOplockStorage.gen.cs new file mode 100644 index 0000000000..e8c6a4e008 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IOplockStorage.gen.cs @@ -0,0 +1,568 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("8d19c834-8879-11d1-83e9-00c04fc2c6d4")] + [NativeName("Name", "IOplockStorage")] + public unsafe partial struct IOplockStorage : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("8d19c834-8879-11d1-83e9-00c04fc2c6d4"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IOplockStorage val) + => Unsafe.As(ref val); + + public IOplockStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppstgOpen = default; + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppstgOpen = default; + return @this->CreateStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppstgOpen = default; + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppstgOpen = default; + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public readonly int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppstgOpen = default; + return @this->OpenStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public readonly int OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppstgOpen = default; + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->OpenStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr OpenStorageEx([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = (IOplockStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersist.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersist.gen.cs new file mode 100644 index 0000000000..7290b01ae3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersist.gen.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000010c-0000-0000-c000-000000000046")] + [NativeName("Name", "IPersist")] + public unsafe partial struct IPersist : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000010c-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPersist val) + => Unsafe.As(ref val); + + public IPersist + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPersist*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistFile.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistFile.gen.cs new file mode 100644 index 0000000000..f2f90419bb --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistFile.gen.cs @@ -0,0 +1,294 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000010b-0000-0000-c000-000000000046")] + [NativeName("Name", "IPersistFile")] + public unsafe partial struct IPersistFile : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000010b-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IPersist(IPersistFile val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPersistFile val) + => Unsafe.As(ref val); + + public IPersistFile + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Load([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszFileName, uint dwMode) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pszFileName, dwMode); + return ret; + } + + /// To be documented. + public readonly int Load([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszFileName, uint dwMode) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszFileNamePtr = &pszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pszFileNamePtr, dwMode); + } + return ret; + } + + /// To be documented. + public readonly int Load([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFileName, uint dwMode) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszFileNamePtr = (byte*) SilkMarshal.StringToPtr(pszFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pszFileNamePtr, dwMode); + SilkMarshal.Free((nint)pszFileNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int Save([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pszFileName, fRemember); + return ret; + } + + /// To be documented. + public readonly int Save([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszFileNamePtr = &pszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pszFileNamePtr, fRemember); + } + return ret; + } + + /// To be documented. + public readonly int Save([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszFileNamePtr = (byte*) SilkMarshal.StringToPtr(pszFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pszFileNamePtr, fRemember); + SilkMarshal.Free((nint)pszFileNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SaveCompleted([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszFileName) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pszFileName); + return ret; + } + + /// To be documented. + public readonly int SaveCompleted([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszFileName) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszFileNamePtr = &pszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pszFileNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int SaveCompleted([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFileName) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszFileNamePtr = (byte*) SilkMarshal.StringToPtr(pszFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pszFileNamePtr); + SilkMarshal.Free((nint)pszFileNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCurFile(char** ppszFileName) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppszFileName); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCurFile(ref char* ppszFileName) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** ppszFileNamePtr = &ppszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppszFileNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetCurFile(string[] ppszFileNameSa) + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppszFileName = (char**) SilkMarshal.StringArrayToPtr(ppszFileNameSa); + var ret = @this->GetCurFile(ppszFileName); + SilkMarshal.CopyPtrToStringArray((nint) ppszFileName, ppszFileNameSa); + SilkMarshal.Free((nint) ppszFileName); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistFile*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStorage.gen.cs new file mode 100644 index 0000000000..15ded68ef7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStorage.gen.cs @@ -0,0 +1,290 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000010a-0000-0000-c000-000000000046")] + [NativeName("Name", "IPersistStorage")] + public unsafe partial struct IPersistStorage : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000010a-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IPersist(IPersistStorage val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPersistStorage val) + => Unsafe.As(ref val); + + public IPersistStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int InitNew(IStorage* pStg) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStg); + return ret; + } + + /// To be documented. + public readonly int InitNew(ref IStorage pStg) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStgPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Load(IStorage* pStg) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStg); + return ret; + } + + /// To be documented. + public readonly int Load(ref IStorage pStg) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStgPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Save(IStorage* pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pStgSave, fSameAsLoad); + return ret; + } + + /// To be documented. + public readonly int Save(ref IStorage pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgSavePtr = &pStgSave) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pStgSavePtr, fSameAsLoad); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SaveCompleted(IStorage* pStgNew) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pStgNew); + return ret; + } + + /// To be documented. + public readonly int SaveCompleted(ref IStorage pStgNew) + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgNewPtr = &pStgNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pStgNewPtr); + } + return ret; + } + + /// To be documented. + public readonly int HandsOffStorage() + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int InitNew(ComPtr pStg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->InitNew((IStorage*) pStg.Handle); + } + + /// To be documented. + public readonly int Load(ComPtr pStg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Load((IStorage*) pStg.Handle); + } + + /// To be documented. + public readonly int Save(ComPtr pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Save((IStorage*) pStgSave.Handle, fSameAsLoad); + } + + /// To be documented. + public readonly int SaveCompleted(ComPtr pStgNew) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SaveCompleted((IStorage*) pStgNew.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStream.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStream.gen.cs new file mode 100644 index 0000000000..14d844b38b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IPersistStream.gen.cs @@ -0,0 +1,244 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000109-0000-0000-c000-000000000046")] + [NativeName("Name", "IPersistStream")] + public unsafe partial struct IPersistStream : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000109-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IPersist(IPersistStream val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IPersistStream val) + => Unsafe.As(ref val); + + public IPersistStream + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Load(Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public readonly int Load(ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Save(Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public readonly int Save(ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeMax(ulong* pcbSize) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSize); + return ret; + } + + /// To be documented. + public readonly int GetSizeMax(ref ulong pcbSize) + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Load(ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public readonly int Save(ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IProcessLock.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProcessLock.gen.cs new file mode 100644 index 0000000000..5ccc4108d7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProcessLock.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("000001d5-0000-0000-c000-000000000046")] + [NativeName("Name", "IProcessLock")] + public unsafe partial struct IProcessLock : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("000001d5-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IProcessLock val) + => Unsafe.As(ref val); + + public IProcessLock + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly uint AddRefOnProcess() + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public readonly uint ReleaseRefOnProcess() + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IProcessLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IProgressNotify.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProgressNotify.gen.cs new file mode 100644 index 0000000000..a1eaa48da7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IProgressNotify.gen.cs @@ -0,0 +1,141 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("a9d758a0-4617-11cf-95fc-00aa00680db4")] + [NativeName("Name", "IProgressNotify")] + public unsafe partial struct IProgressNotify : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a9d758a0-4617-11cf-95fc-00aa00680db4"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IProgressNotify val) + => Unsafe.As(ref val); + + public IProgressNotify + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int OnProgress(uint dwProgressCurrent, uint dwProgressMaximum, Silk.NET.Core.Bool32 fAccurate, Silk.NET.Core.Bool32 fOwner) + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwProgressCurrent, dwProgressMaximum, fAccurate, fOwner); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IProgressNotify*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IROTData.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IROTData.gen.cs new file mode 100644 index 0000000000..997349f714 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IROTData.gen.cs @@ -0,0 +1,205 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("f29f6bc0-5021-11ce-aa15-00006901293f")] + [NativeName("Name", "IROTData")] + public unsafe partial struct IROTData : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("f29f6bc0-5021-11ce-aa15-00006901293f"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IROTData val) + => Unsafe.As(ref val); + + public IROTData + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComparisonData(byte* pbData, uint cbMax, uint* pcbData) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbData, cbMax, pcbData); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComparisonData(byte* pbData, uint cbMax, ref uint pcbData) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbDataPtr = &pcbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbData, cbMax, pcbDataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetComparisonData(ref byte pbData, uint cbMax, uint* pcbData) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbDataPtr = &pbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbData); + } + return ret; + } + + /// To be documented. + public readonly int GetComparisonData(ref byte pbData, uint cbMax, ref uint pcbData) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbDataPtr = &pbData) + { + fixed (uint* pcbDataPtr = &pcbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbDataPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetComparisonData([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbData, uint cbMax, uint* pcbData) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbDataPtr = (byte*) SilkMarshal.StringToPtr(pbData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbData); + SilkMarshal.Free((nint)pbDataPtr); + return ret; + } + + /// To be documented. + public readonly int GetComparisonData([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbData, uint cbMax, ref uint pcbData) + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbDataPtr = (byte*) SilkMarshal.StringToPtr(pbData, NativeStringEncoding.UTF8); + fixed (uint* pcbDataPtr = &pcbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbDataPtr); + } + SilkMarshal.Free((nint)pbDataPtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IROTData*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IRootStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRootStorage.gen.cs new file mode 100644 index 0000000000..1131d7934c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRootStorage.gen.cs @@ -0,0 +1,164 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000012-0000-0000-c000-000000000046")] + [NativeName("Name", "IRootStorage")] + public unsafe partial struct IRootStorage : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000012-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IRootStorage val) + => Unsafe.As(ref val); + + public IRootStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SwitchToFile(char* pszFile) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszFile); + return ret; + } + + /// To be documented. + public readonly int SwitchToFile(ref char pszFile) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszFilePtr = &pszFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszFilePtr); + } + return ret; + } + + /// To be documented. + public readonly int SwitchToFile([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFile) + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszFilePtr = (byte*) SilkMarshal.StringToPtr(pszFile, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszFilePtr); + SilkMarshal.Free((nint)pszFilePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IRootStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IRunnableObject.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRunnableObject.gen.cs new file mode 100644 index 0000000000..1f583e4c81 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRunnableObject.gen.cs @@ -0,0 +1,209 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000126-0000-0000-c000-000000000046")] + [NativeName("Name", "IRunnableObject")] + public unsafe partial struct IRunnableObject : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000126-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IRunnableObject val) + => Unsafe.As(ref val); + + public IRunnableObject + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetRunningClass(Guid* lpClsid) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpClsid); + return ret; + } + + /// To be documented. + public readonly int GetRunningClass(ref Guid lpClsid) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* lpClsidPtr = &lpClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpClsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Run(IBindCtx* pbc) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pbc); + return ret; + } + + /// To be documented. + public readonly int Run(ref IBindCtx pbc) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pbcPtr); + } + return ret; + } + + /// To be documented. + public readonly Silk.NET.Core.Bool32 IsRunning() + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + Silk.NET.Core.Bool32 ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly int LockRunning(Silk.NET.Core.Bool32 fLock, Silk.NET.Core.Bool32 fLastUnlockCloses) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, fLock, fLastUnlockCloses); + return ret; + } + + /// To be documented. + public readonly int SetContainedObject(Silk.NET.Core.Bool32 fContained) + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, fContained); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Run(ComPtr pbc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Run((IBindCtx*) pbc.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IRunnableObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IRunningObjectTable.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRunningObjectTable.gen.cs new file mode 100644 index 0000000000..91f1d2d87c --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRunningObjectTable.gen.cs @@ -0,0 +1,512 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000010-0000-0000-c000-000000000046")] + [NativeName("Name", "IRunningObjectTable")] + public unsafe partial struct IRunningObjectTable : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000010-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IRunningObjectTable val) + => Unsafe.As(ref val); + + public IRunningObjectTable + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, IMoniker* pmkObjectName, uint* pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectName, pdwRegister); + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, IMoniker* pmkObjectName, ref uint pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectName, pdwRegisterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, ref IMoniker pmkObjectName, uint* pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectNamePtr, pdwRegister); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, ref IMoniker pmkObjectName, ref uint pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectNamePtr, pdwRegisterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, IMoniker* pmkObjectName, uint* pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectName, pdwRegister); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, IMoniker* pmkObjectName, ref uint pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectName, pdwRegisterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ref IMoniker pmkObjectName, uint* pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectNamePtr, pdwRegister); + } + } + return ret; + } + + /// To be documented. + public readonly int Register(uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ref IMoniker pmkObjectName, ref uint pdwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectNamePtr, pdwRegisterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Revoke(uint dwRegister) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwRegister); + return ret; + } + + /// To be documented. + public readonly unsafe int IsRunning(IMoniker* pmkObjectName) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkObjectName); + return ret; + } + + /// To be documented. + public readonly int IsRunning(ref IMoniker pmkObjectName) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkObjectNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectA(IMoniker* pmkObjectName, Silk.NET.Core.Native.IUnknown** ppunkObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectName, ppunkObject); + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectA(IMoniker* pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppunkObjectPtr = &ppunkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectName, ppunkObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectA(ref IMoniker pmkObjectName, Silk.NET.Core.Native.IUnknown** ppunkObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectNamePtr, ppunkObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetObjectA(ref IMoniker pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (Silk.NET.Core.Native.IUnknown** ppunkObjectPtr = &ppunkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectNamePtr, ppunkObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int NoteChangeTime(uint dwRegister, Filetime* pfiletime) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, dwRegister, pfiletime); + return ret; + } + + /// To be documented. + public readonly int NoteChangeTime(uint dwRegister, ref Filetime pfiletime) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pfiletimePtr = &pfiletime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, dwRegister, pfiletimePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(IMoniker* pmkObjectName, Filetime* pfiletime) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectName, pfiletime); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(IMoniker* pmkObjectName, ref Filetime pfiletime) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pfiletimePtr = &pfiletime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectName, pfiletimePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ref IMoniker pmkObjectName, Filetime* pfiletime) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectNamePtr, pfiletime); + } + return ret; + } + + /// To be documented. + public readonly int GetTimeOfLastChange(ref IMoniker pmkObjectName, ref Filetime pfiletime) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (Filetime* pfiletimePtr = &pfiletime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectNamePtr, pfiletimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int EnumRunning(IEnumMoniker** ppenumMoniker) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppenumMoniker); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumRunning(ref IEnumMoniker* ppenumMoniker) + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumMoniker** ppenumMonikerPtr = &ppenumMoniker) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppenumMonikerPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, ComPtr punkObject, ComPtr pmkObjectName, uint* pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, (IMoniker*) pmkObjectName.Handle, pdwRegister); + } + + /// To be documented. + public readonly int Register(uint grfFlags, ComPtr punkObject, ComPtr pmkObjectName, ref uint pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, (IMoniker*) pmkObjectName.Handle, ref pdwRegister); + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, ComPtr punkObject, ref IMoniker pmkObjectName, uint* pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, ref pmkObjectName, pdwRegister); + } + + /// To be documented. + public readonly int Register(uint grfFlags, ComPtr punkObject, ref IMoniker pmkObjectName, ref uint pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, ref pmkObjectName, ref pdwRegister); + } + + /// To be documented. + public readonly unsafe int Register(uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ComPtr pmkObjectName, uint* pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Register(grfFlags, ref punkObject, (IMoniker*) pmkObjectName.Handle, pdwRegister); + } + + /// To be documented. + public readonly int Register(uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ComPtr pmkObjectName, ref uint pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Register(grfFlags, ref punkObject, (IMoniker*) pmkObjectName.Handle, ref pdwRegister); + } + + /// To be documented. + public readonly int IsRunning(ComPtr pmkObjectName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->IsRunning((IMoniker*) pmkObjectName.Handle); + } + + /// To be documented. + public readonly int GetObjectA(ComPtr pmkObjectName, ref ComPtr ppunkObject) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetObjectA((IMoniker*) pmkObjectName.Handle, (Silk.NET.Core.Native.IUnknown**) ppunkObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetObjectA(ComPtr pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetObjectA((IMoniker*) pmkObjectName.Handle, ref ppunkObject); + } + + /// To be documented. + public readonly int GetObjectA(ref IMoniker pmkObjectName, ref ComPtr ppunkObject) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetObjectA(ref pmkObjectName, (Silk.NET.Core.Native.IUnknown**) ppunkObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetTimeOfLastChange(ComPtr pmkObjectName, Filetime* pfiletime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange((IMoniker*) pmkObjectName.Handle, pfiletime); + } + + /// To be documented. + public readonly int GetTimeOfLastChange(ComPtr pmkObjectName, ref Filetime pfiletime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetTimeOfLastChange((IMoniker*) pmkObjectName.Handle, ref pfiletime); + } + + /// To be documented. + public readonly int EnumRunning(ref ComPtr ppenumMoniker) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumRunning((IEnumMoniker**) ppenumMoniker.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IRunningObjectTable*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IStorage.gen.cs new file mode 100644 index 0000000000..dae5518205 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IStorage.gen.cs @@ -0,0 +1,2339 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("0000000b-0000-0000-c000-000000000046")] + [NativeName("Name", "IStorage")] + public unsafe partial struct IStorage : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("0000000b-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IStorage val) + => Unsafe.As(ref val); + + public IStorage + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, reserved1, reserved2, ppstm); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, reserved1, reserved2, ppstmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstm); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstmPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstm); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstmPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1, grfMode, reserved2, ppstm); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1, grfMode, reserved2, ppstmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* reserved1Ptr = &reserved1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1Ptr, grfMode, reserved2, ppstm); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* reserved1Ptr = &reserved1) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1Ptr, grfMode, reserved2, ppstmPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstm); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstmPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void* reserved1Ptr = &reserved1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstm); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void* reserved1Ptr = &reserved1) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstmPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstm); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstmPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (void* reserved1Ptr = &reserved1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstm); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (void* reserved1Ptr = &reserved1) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstmPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsName, grfMode, reserved1, reserved2, ppstg); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsName, grfMode, reserved1, reserved2, ppstgPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstg); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstgPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstgPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExcludePtr, reserved, ppstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstg); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstg); + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstg); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstg); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstg); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstgPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstg); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstg); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstgPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstg); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExclude, pstgDest); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExclude, pstgDestPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExcludePtr, pstgDest); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExcludePtr, pstgDestPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExclude, pstgDest); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExclude, pstgDestPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExcludePtr, pstgDest); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExcludePtr, pstgDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDest, pwcsNewName, grfFlags); + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDest, pwcsNewNamePtr, grfFlags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDest, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDestPtr, pwcsNewName, grfFlags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDestPtr, pwcsNewNamePtr, grfFlags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDestPtr, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewName, grfFlags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewName, grfFlags); + } + } + return ret; + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + } + } + } + return ret; + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewName, grfFlags); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewName, grfFlags); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgDestPtr = &pstgDest) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgDestPtr = &pstgDest) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly int Commit(uint grfCommitFlags) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, grfCommitFlags); + return ret; + } + + /// To be documented. + public readonly int Revert() + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumElements(uint reserved1, void* reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2, reserved3, ppenum); + return ret; + } + + /// To be documented. + public readonly unsafe int EnumElements(uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IEnumSTATSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2, reserved3, ppenumPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int EnumElements(uint reserved1, ref T0 reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* reserved2Ptr = &reserved2) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2Ptr, reserved3, ppenum); + } + return ret; + } + + /// To be documented. + public readonly unsafe int EnumElements(uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* reserved2Ptr = &reserved2) + { + fixed (IEnumSTATSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2Ptr, reserved3, ppenumPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DestroyElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pwcsName); + return ret; + } + + /// To be documented. + public readonly int DestroyElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pwcsNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int DestroyElement([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pwcsNamePtr); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldName, pwcsNewName); + return ret; + } + + /// To be documented. + public readonly unsafe int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldName, pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldName, pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNewNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsOldNamePtr = &pwcsOldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewName); + } + return ret; + } + + /// To be documented. + public readonly int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsOldNamePtr = &pwcsOldName) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsOldNamePtr = &pwcsOldName) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsOldNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsOldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewName); + SilkMarshal.Free((nint)pwcsOldNamePtr); + return ret; + } + + /// To be documented. + public readonly int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsOldNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsOldName, NativeStringEncoding.UTF8); + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + } + SilkMarshal.Free((nint)pwcsOldNamePtr); + return ret; + } + + /// To be documented. + public readonly int RenameElement([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsOldNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsOldName, NativeStringEncoding.UTF8); + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsOldNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patime, pmtime); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patime, pmtimePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patimePtr, pmtime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patimePtr, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patime, pmtime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patime, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patimePtr, pmtime); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patimePtr, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtime); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtime); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtime); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtime); + } + } + } + return ret; + } + + /// To be documented. + public readonly int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtimePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtime); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtimePtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtime); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtimePtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtime); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtimePtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtime); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly int SetElementTimes([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtimePtr); + } + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SetClass(Guid* clsid) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, clsid); + return ret; + } + + /// To be documented. + public readonly int SetClass(ref Guid clsid) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidPtr = &clsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, clsidPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetStateBits(uint grfStateBits, uint grfMask) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, grfStateBits, grfMask); + return ret; + } + + /// To be documented. + public readonly unsafe int Stat(STATSTG* pstatstg, uint grfStatFlag) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pstatstg, grfStatFlag); + return ret; + } + + /// To be documented. + public readonly int Stat(ref STATSTG pstatstg, uint grfStatFlag) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (STATSTG* pstatstgPtr = &pstatstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pstatstgPtr, grfStatFlag); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStream(pwcsName, grfMode, reserved1, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStream(in pwcsName, grfMode, reserved1, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStream(pwcsName, grfMode, reserved1, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStream(pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStream(pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStream(in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStream(in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStream(pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly int OpenStream([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStream(pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStorage(pwcsName, grfMode, reserved1, reserved2, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStorage(in pwcsName, grfMode, reserved1, reserved2, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStorage(pwcsName, grfMode, reserved1, reserved2, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int OpenStorage([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo(ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public readonly int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, in pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(in pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(in pwcsName, (IStorage*) pstgDest.Handle, in pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(in pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly unsafe int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, in pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly int MoveElementTo([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public readonly unsafe int EnumElements(uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumElements(reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly int EnumElements(uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->EnumElements(reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs new file mode 100644 index 0000000000..ddc38c3233 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs @@ -0,0 +1,332 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("000001d4-0000-0000-c000-000000000046")] + [NativeName("Name", "ISurrogateService")] + public unsafe partial struct ISurrogateService : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("000001d4-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ISurrogateService val) + => Unsafe.As(ref val); + + public ISurrogateService + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Init(Guid* rguidProcessID, IProcessLock* pProcessLock, int* pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLock, pfApplicationAware); + return ret; + } + + /// To be documented. + public readonly unsafe int Init(Guid* rguidProcessID, IProcessLock* pProcessLock, ref int pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLock, pfApplicationAwarePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Init(Guid* rguidProcessID, ref IProcessLock pProcessLock, int* pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLockPtr, pfApplicationAware); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Init(Guid* rguidProcessID, ref IProcessLock pProcessLock, ref int pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLockPtr, pfApplicationAwarePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Init(ref Guid rguidProcessID, IProcessLock* pProcessLock, int* pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLock, pfApplicationAware); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Init(ref Guid rguidProcessID, IProcessLock* pProcessLock, ref int pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLock, pfApplicationAwarePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Init(ref Guid rguidProcessID, ref IProcessLock pProcessLock, int* pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLockPtr, pfApplicationAware); + } + } + return ret; + } + + /// To be documented. + public readonly int Init(ref Guid rguidProcessID, ref IProcessLock pProcessLock, ref int pfApplicationAware) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLockPtr, pfApplicationAwarePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ApplicationLaunch(Guid* rguidApplID, TagApplicationType appType) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplID, appType); + return ret; + } + + /// To be documented. + public readonly int ApplicationLaunch(ref Guid rguidApplID, TagApplicationType appType) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidApplIDPtr = &rguidApplID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplIDPtr, appType); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ApplicationFree(Guid* rguidApplID) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rguidApplID); + return ret; + } + + /// To be documented. + public readonly int ApplicationFree(ref Guid rguidApplID) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rguidApplIDPtr = &rguidApplID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rguidApplIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int CatalogRefresh(uint ulReserved) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ulReserved); + return ret; + } + + /// To be documented. + public readonly int ProcessShutdown(TagShutdownType shutdownType) + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, shutdownType); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int Init(Guid* rguidProcessID, ComPtr pProcessLock, int* pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Init(rguidProcessID, (IProcessLock*) pProcessLock.Handle, pfApplicationAware); + } + + /// To be documented. + public readonly unsafe int Init(Guid* rguidProcessID, ComPtr pProcessLock, ref int pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Init(rguidProcessID, (IProcessLock*) pProcessLock.Handle, ref pfApplicationAware); + } + + /// To be documented. + public readonly unsafe int Init(ref Guid rguidProcessID, ComPtr pProcessLock, int* pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Init(ref rguidProcessID, (IProcessLock*) pProcessLock.Handle, pfApplicationAware); + } + + /// To be documented. + public readonly int Init(ref Guid rguidProcessID, ComPtr pProcessLock, ref int pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Init(ref rguidProcessID, (IProcessLock*) pProcessLock.Handle, ref pfApplicationAware); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IThumbnailExtractor.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IThumbnailExtractor.gen.cs new file mode 100644 index 0000000000..8fd0d03050 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IThumbnailExtractor.gen.cs @@ -0,0 +1,465 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("969dc708-5c76-11d1-8d86-0000f804b057")] + [NativeName("Name", "IThumbnailExtractor")] + public unsafe partial struct IThumbnailExtractor : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("969dc708-5c76-11d1-8d86-0000f804b057"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IThumbnailExtractor val) + => Unsafe.As(ref val); + + public IThumbnailExtractor + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmap); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int OnFileUpdated(IStorage* pStg) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pStg); + return ret; + } + + /// To be documented. + public readonly int OnFileUpdated(ref IStorage pStg) + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pStgPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, ref pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, ref pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, ref pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public readonly unsafe int ExtractThumbnail(ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, ref pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public readonly int OnFileUpdated(ComPtr pStg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->OnFileUpdated((IStorage*) pStg.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IThumbnailExtractor*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ITimeAndNoticeControl.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITimeAndNoticeControl.gen.cs new file mode 100644 index 0000000000..362937c896 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ITimeAndNoticeControl.gen.cs @@ -0,0 +1,141 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("bc0bf6ae-8878-11d1-83e9-00c04fc2c6d4")] + [NativeName("Name", "ITimeAndNoticeControl")] + public unsafe partial struct ITimeAndNoticeControl : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("bc0bf6ae-8878-11d1-83e9-00c04fc2c6d4"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(ITimeAndNoticeControl val) + => Unsafe.As(ref val); + + public ITimeAndNoticeControl + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int SuppressChanges(uint res1, uint res2) + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, res1, res2); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (ITimeAndNoticeControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IUrlMon.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IUrlMon.gen.cs new file mode 100644 index 0000000000..dd904a6134 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IUrlMon.gen.cs @@ -0,0 +1,4992 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [Guid("00000026-0000-0000-c000-000000000046")] + [NativeName("Name", "IUrlMon")] + public unsafe partial struct IUrlMon : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000026-0000-0000-c000-000000000046"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IUrlMon val) + => Unsafe.As(ref val); + + public IUrlMon + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly unsafe int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public readonly int AsyncGetClassBits(ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IUrlMon*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/InitializeSpyVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/InitializeSpyVtblExtensions.gen.cs new file mode 100644 index 0000000000..30630b6266 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/InitializeSpyVtblExtensions.gen.cs @@ -0,0 +1,157 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class InitializeSpyVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int PreInitialize(this ComPtr thisVtbl, uint dwCoInit, uint dwCurThreadAptRefs) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCoInit, dwCurThreadAptRefs); + return ret; + } + + /// To be documented. + public static int PostInitialize(this ComPtr thisVtbl, int hrCoInit, uint dwCoInit, uint dwNewThreadAptRefs) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, hrCoInit, dwCoInit, dwNewThreadAptRefs); + return ret; + } + + /// To be documented. + public static int PreUninitialize(this ComPtr thisVtbl, uint dwCurThreadAptRefs) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, dwCurThreadAptRefs); + return ret; + } + + /// To be documented. + public static int PostUninitialize(this ComPtr thisVtbl, uint dwNewThreadAptRefs) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, dwNewThreadAptRefs); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..c2380dc60e --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs @@ -0,0 +1,245 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class LayoutStorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int LayoutScript(this ComPtr thisVtbl, TagStorageLayout* pStorageLayout, uint nEntries, uint glfInterleavedFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayout, nEntries, glfInterleavedFlag); + return ret; + } + + /// To be documented. + public static int LayoutScript(this ComPtr thisVtbl, ref TagStorageLayout pStorageLayout, uint nEntries, uint glfInterleavedFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (TagStorageLayout* pStorageLayoutPtr = &pStorageLayout) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayoutPtr, nEntries, glfInterleavedFlag); + } + return ret; + } + + /// To be documented. + public static int BeginMonitor(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static int EndMonitor(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int ReLayoutDocfile(this ComPtr thisVtbl, char* pwcsNewDfName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNewDfName); + return ret; + } + + /// To be documented. + public static int ReLayoutDocfile(this ComPtr thisVtbl, ref char pwcsNewDfName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNewDfNamePtr = &pwcsNewDfName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNewDfNamePtr); + } + return ret; + } + + /// To be documented. + public static int ReLayoutDocfile(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewDfName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNewDfNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewDfName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNewDfNamePtr); + SilkMarshal.Free((nint)pwcsNewDfNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int ReLayoutDocfileOnILockBytes(this ComPtr thisVtbl, ILockBytes* pILockBytes) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pILockBytes); + return ret; + } + + /// To be documented. + public static int ReLayoutDocfileOnILockBytes(this ComPtr thisVtbl, ref ILockBytes pILockBytes) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ILockBytes* pILockBytesPtr = &pILockBytes) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pILockBytesPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int LayoutScript(this ComPtr thisVtbl, Span pStorageLayout, uint nEntries, uint glfInterleavedFlag) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LayoutScript(ref pStorageLayout.GetPinnableReference(), nEntries, glfInterleavedFlag); + } + + /// To be documented. + public static int ReLayoutDocfile(this ComPtr thisVtbl, Span pwcsNewDfName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReLayoutDocfile(ref pwcsNewDfName.GetPinnableReference()); + } + + /// To be documented. + public static int ReLayoutDocfileOnILockBytes(this ComPtr thisVtbl, ComPtr pILockBytes) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ReLayoutDocfileOnILockBytes((ILockBytes*) pILockBytes.Handle); + } + + /// To be documented. + public static int ReLayoutDocfileOnILockBytes(this ComPtr thisVtbl, Span pILockBytes) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReLayoutDocfileOnILockBytes(ref pILockBytes.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/LockBytesVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/LockBytesVtblExtensions.gen.cs new file mode 100644 index 0000000000..ddb89f13de --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/LockBytesVtblExtensions.gen.cs @@ -0,0 +1,330 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class LockBytesVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int ReadAt(this ComPtr thisVtbl, ulong ulOffset, void* pv, uint cb, uint* pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pv, cb, pcbRead); + return ret; + } + + /// To be documented. + public static unsafe int ReadAt(this ComPtr thisVtbl, ulong ulOffset, void* pv, uint cb, ref uint pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pv, cb, pcbReadPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ReadAt(this ComPtr thisVtbl, ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pvPtr, cb, pcbRead); + } + return ret; + } + + /// To be documented. + public static int ReadAt(this ComPtr thisVtbl, ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, ulOffset, pvPtr, cb, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public static unsafe int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public static int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, ulOffset, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static int Flush(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static int SetSize(this ComPtr thisVtbl, ulong cb) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, cb); + return ret; + } + + /// To be documented. + public static int LockRegion(this ComPtr thisVtbl, ulong libOffset, ulong cb, uint dwLockType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public static int UnlockRegion(this ComPtr thisVtbl, ulong libOffset, ulong cb, uint dwLockType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public static unsafe int Stat(this ComPtr thisVtbl, STATSTG* pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pstatstg, grfStatFlag); + return ret; + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, ref STATSTG pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATSTG* pstatstgPtr = &pstatstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pstatstgPtr, grfStatFlag); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int ReadAt(this ComPtr thisVtbl, ulong ulOffset, void* pv, uint cb, Span pcbRead) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadAt(ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int ReadAt(this ComPtr thisVtbl, ulong ulOffset, Span pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadAt(ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + public static int ReadAt(this ComPtr thisVtbl, ulong ulOffset, Span pv, uint cb, Span pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ReadAt(ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteAt(ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteAt(ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + public static int WriteAt(this ComPtr thisVtbl, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteAt(ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, Span pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Stat(ref pstatstg.GetPinnableReference(), grfStatFlag); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/MallocSpyVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/MallocSpyVtblExtensions.gen.cs new file mode 100644 index 0000000000..5898f6f308 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/MallocSpyVtblExtensions.gen.cs @@ -0,0 +1,398 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class MallocSpyVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static nuint PreAlloc(this ComPtr thisVtbl, nuint cbRequest) + { + var @this = thisVtbl.Handle; + nuint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, cbRequest); + return ret; + } + + /// To be documented. + public static unsafe void* PostAlloc(this ComPtr thisVtbl, void* pActual) + { + var @this = thisVtbl.Handle; + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pActual); + return ret; + } + + /// To be documented. + public static unsafe void* PostAlloc(this ComPtr thisVtbl, ref T0 pActual) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + void* ret = default; + fixed (void* pActualPtr = &pActual) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe void* PreFree(this ComPtr thisVtbl, void* pRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pRequest, fSpyed); + return ret; + } + + /// To be documented. + public static unsafe void* PreFree(this ComPtr thisVtbl, ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + void* ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public static void PostFree(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, fSpyed); + } + + /// To be documented. + public static unsafe nuint PreRealloc(this ComPtr thisVtbl, void* pRequest, nuint cbRequest, void** ppNewRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + nuint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequest, cbRequest, ppNewRequest, fSpyed); + return ret; + } + + /// To be documented. + public static unsafe nuint PreRealloc(this ComPtr thisVtbl, void* pRequest, nuint cbRequest, ref void* ppNewRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + nuint ret = default; + fixed (void** ppNewRequestPtr = &ppNewRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequest, cbRequest, ppNewRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public static unsafe nuint PreRealloc(this ComPtr thisVtbl, ref T0 pRequest, nuint cbRequest, void** ppNewRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + nuint ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequestPtr, cbRequest, ppNewRequest, fSpyed); + } + return ret; + } + + /// To be documented. + public static unsafe nuint PreRealloc(this ComPtr thisVtbl, ref T0 pRequest, nuint cbRequest, ref void* ppNewRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + nuint ret = default; + fixed (void* pRequestPtr = &pRequest) + { + fixed (void** ppNewRequestPtr = &ppNewRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pRequestPtr, cbRequest, ppNewRequestPtr, fSpyed); + } + } + return ret; + } + + /// To be documented. + public static unsafe void* PostRealloc(this ComPtr thisVtbl, void* pActual, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pActual, fSpyed); + return ret; + } + + /// To be documented. + public static unsafe void* PostRealloc(this ComPtr thisVtbl, ref T0 pActual, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + void* ret = default; + fixed (void* pActualPtr = &pActual) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pActualPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public static unsafe void* PreGetSize(this ComPtr thisVtbl, void* pRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pRequest, fSpyed); + return ret; + } + + /// To be documented. + public static unsafe void* PreGetSize(this ComPtr thisVtbl, ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + void* ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public static nuint PostGetSize(this ComPtr thisVtbl, nuint cbActual, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + nuint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, cbActual, fSpyed); + return ret; + } + + /// To be documented. + public static unsafe void* PreDidAlloc(this ComPtr thisVtbl, void* pRequest, Silk.NET.Core.Bool32 fSpyed) + { + var @this = thisVtbl.Handle; + void* ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pRequest, fSpyed); + return ret; + } + + /// To be documented. + public static unsafe void* PreDidAlloc(this ComPtr thisVtbl, ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + void* ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pRequestPtr, fSpyed); + } + return ret; + } + + /// To be documented. + public static unsafe int PostDidAlloc(this ComPtr thisVtbl, void* pRequest, Silk.NET.Core.Bool32 fSpyed, int fActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pRequest, fSpyed, fActual); + return ret; + } + + /// To be documented. + public static int PostDidAlloc(this ComPtr thisVtbl, ref T0 pRequest, Silk.NET.Core.Bool32 fSpyed, int fActual) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pRequestPtr = &pRequest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pRequestPtr, fSpyed, fActual); + } + return ret; + } + + /// To be documented. + public static void PreHeapMinimize(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this); + } + + /// To be documented. + public static void PostHeapMinimize(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this); + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe void* PostAlloc(this ComPtr thisVtbl, Span pActual) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PostAlloc(ref pActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe void* PreFree(this ComPtr thisVtbl, Span pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PreFree(ref pRequest.GetPinnableReference(), fSpyed); + } + + /// To be documented. + public static unsafe nuint PreRealloc(this ComPtr thisVtbl, Span pRequest, nuint cbRequest, void** ppNewRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PreRealloc(ref pRequest.GetPinnableReference(), cbRequest, ppNewRequest, fSpyed); + } + + /// To be documented. + public static unsafe nuint PreRealloc(this ComPtr thisVtbl, Span pRequest, nuint cbRequest, ref void* ppNewRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PreRealloc(ref pRequest.GetPinnableReference(), cbRequest, ref ppNewRequest, fSpyed); + } + + /// To be documented. + public static unsafe void* PostRealloc(this ComPtr thisVtbl, Span pActual, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PostRealloc(ref pActual.GetPinnableReference(), fSpyed); + } + + /// To be documented. + public static unsafe void* PreGetSize(this ComPtr thisVtbl, Span pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PreGetSize(ref pRequest.GetPinnableReference(), fSpyed); + } + + /// To be documented. + public static unsafe void* PreDidAlloc(this ComPtr thisVtbl, Span pRequest, Silk.NET.Core.Bool32 fSpyed) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PreDidAlloc(ref pRequest.GetPinnableReference(), fSpyed); + } + + /// To be documented. + public static int PostDidAlloc(this ComPtr thisVtbl, Span pRequest, Silk.NET.Core.Bool32 fSpyed, int fActual) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->PostDidAlloc(ref pRequest.GetPinnableReference(), fSpyed, fActual); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs new file mode 100644 index 0000000000..04e2b68dde --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs @@ -0,0 +1,251 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class MessageFilterVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); + return ret; + } + + /// To be documented. + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) + { + var @this = thisVtbl.Handle; + uint ret = default; + fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, ref T0 htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + uint ret = default; + fixed (void* htaskCallerPtr = &htaskCaller) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfo); + } + return ret; + } + + /// To be documented. + public static uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, ref T0 htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + uint ret = default; + fixed (void* htaskCallerPtr = &htaskCaller) + { + fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe uint RetryRejectedCall(this ComPtr thisVtbl, void* htaskCallee, uint dwTickCount, uint dwRejectType) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, htaskCallee, dwTickCount, dwRejectType); + return ret; + } + + /// To be documented. + public static uint RetryRejectedCall(this ComPtr thisVtbl, ref T0 htaskCallee, uint dwTickCount, uint dwRejectType) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + uint ret = default; + fixed (void* htaskCalleePtr = &htaskCallee) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, htaskCalleePtr, dwTickCount, dwRejectType); + } + return ret; + } + + /// To be documented. + public static unsafe uint MessagePending(this ComPtr thisVtbl, void* htaskCallee, uint dwTickCount, uint dwPendingType) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, htaskCallee, dwTickCount, dwPendingType); + return ret; + } + + /// To be documented. + public static uint MessagePending(this ComPtr thisVtbl, ref T0 htaskCallee, uint dwTickCount, uint dwPendingType) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + uint ret = default; + fixed (void* htaskCalleePtr = &htaskCallee) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, htaskCalleePtr, dwTickCount, dwPendingType); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, Span lpInterfaceInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->HandleInComingCall(dwCallType, htaskCaller, dwTickCount, ref lpInterfaceInfo.GetPinnableReference()); + } + + /// To be documented. + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, Span htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->HandleInComingCall(dwCallType, ref htaskCaller.GetPinnableReference(), dwTickCount, lpInterfaceInfo); + } + + /// To be documented. + public static uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, Span htaskCaller, uint dwTickCount, Span lpInterfaceInfo) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->HandleInComingCall(dwCallType, ref htaskCaller.GetPinnableReference(), dwTickCount, ref lpInterfaceInfo.GetPinnableReference()); + } + + /// To be documented. + public static uint RetryRejectedCall(this ComPtr thisVtbl, Span htaskCallee, uint dwTickCount, uint dwRejectType) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RetryRejectedCall(ref htaskCallee.GetPinnableReference(), dwTickCount, dwRejectType); + } + + /// To be documented. + public static uint MessagePending(this ComPtr thisVtbl, Span htaskCallee, uint dwTickCount, uint dwPendingType) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MessagePending(ref htaskCallee.GetPinnableReference(), dwTickCount, dwPendingType); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/MonikerVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/MonikerVtblExtensions.gen.cs new file mode 100644 index 0000000000..4ce787cd5b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/MonikerVtblExtensions.gen.cs @@ -0,0 +1,4039 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class MonikerVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSizeMax(this ComPtr thisVtbl, ulong* pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSize); + return ret; + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, ref ulong pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResult, ppvResult); + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResult, ppvResultPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResultPtr, ppvResult); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeft, riidResultPtr, ppvResultPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResult, ppvResult); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResult, ppvResultPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResultPtr, ppvResult); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbc, pmkToLeftPtr, riidResultPtr, ppvResultPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResult, ppvResult); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResult, ppvResultPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResultPtr, ppvResult); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeft, riidResultPtr, ppvResultPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResult, ppvResult); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResult, ppvResultPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResultPtr, ppvResult); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidResultPtr = &riidResult) + { + fixed (void** ppvResultPtr = &ppvResult) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pbcPtr, pmkToLeftPtr, riidResultPtr, ppvResultPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riid, ppvObj); + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riid, ppvObjPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riidPtr, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeft, riidPtr, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbc, pmkToLeftPtr, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riid, ppvObj); + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riid, ppvObjPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riidPtr, ppvObj); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeft, riidPtr, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riid, ppvObj); + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riid, ppvObjPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riidPtr, ppvObj); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjPtr = &ppvObj) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pbcPtr, pmkToLeftPtr, riidPtr, ppvObjPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeft, ppmkReduced); + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, IBindCtx* pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeft, ppmkReducedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, IBindCtx* pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeftPtr, ppmkReduced); + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, IBindCtx* pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbc, dwReduceHowFar, ppmkToLeftPtr, ppmkReducedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeft, ppmkReduced); + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeft, ppmkReducedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeftPtr, ppmkReduced); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkToLeftPtr = &ppmkToLeft) + { + fixed (IMoniker** ppmkReducedPtr = &ppmkReduced) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this, pbcPtr, dwReduceHowFar, ppmkToLeftPtr, ppmkReducedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, IMoniker* pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, IMoniker** ppmkComposite) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRight, fOnlyIfNotGeneric, ppmkComposite); + return ret; + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, IMoniker* pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkCompositePtr = &ppmkComposite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRight, fOnlyIfNotGeneric, ppmkCompositePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, ref IMoniker pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, IMoniker** ppmkComposite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkRightPtr = &pmkRight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRightPtr, fOnlyIfNotGeneric, ppmkComposite); + } + return ret; + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, ref IMoniker pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkRightPtr = &pmkRight) + { + fixed (IMoniker** ppmkCompositePtr = &ppmkComposite) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, pmkRightPtr, fOnlyIfNotGeneric, ppmkCompositePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Enum(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fForward, IEnumMoniker** ppenumMoniker) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, fForward, ppenumMoniker); + return ret; + } + + /// To be documented. + public static unsafe int Enum(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fForward, ref IEnumMoniker* ppenumMoniker) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumMoniker** ppenumMonikerPtr = &ppenumMoniker) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, fForward, ppenumMonikerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int IsEqual(this ComPtr thisVtbl, IMoniker* pmkOtherMoniker) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmkOtherMoniker); + return ret; + } + + /// To be documented. + public static int IsEqual(this ComPtr thisVtbl, ref IMoniker pmkOtherMoniker) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkOtherMonikerPtr = &pmkOtherMoniker) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pmkOtherMonikerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Hash(this ComPtr thisVtbl, uint* pdwHash) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pdwHash); + return ret; + } + + /// To be documented. + public static int Hash(this ComPtr thisVtbl, ref uint pdwHash) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwHashPtr = &pdwHash) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pdwHashPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeft, pmkNewlyRunning); + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeft, pmkNewlyRunningPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeftPtr, pmkNewlyRunning); + } + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbc, pmkToLeftPtr, pmkNewlyRunningPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeft, pmkNewlyRunning); + } + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeft, pmkNewlyRunningPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeftPtr, pmkNewlyRunning); + } + } + return ret; + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref IMoniker pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker* pmkNewlyRunningPtr = &pmkNewlyRunning) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, pbcPtr, pmkToLeftPtr, pmkNewlyRunningPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeft, pFileTime); + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref Filetime pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeft, pFileTimePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeftPtr, pFileTime); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Filetime pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbc, pmkToLeftPtr, pFileTimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeft, pFileTime); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Filetime pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeft, pFileTimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeftPtr, pFileTime); + } + } + return ret; + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Filetime pFileTime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (Filetime* pFileTimePtr = &pFileTime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, pbcPtr, pmkToLeftPtr, pFileTimePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Inverse(this ComPtr thisVtbl, IMoniker** ppmk) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, ppmk); + return ret; + } + + /// To be documented. + public static unsafe int Inverse(this ComPtr thisVtbl, ref IMoniker* ppmk) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkPtr = &ppmk) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, ppmkPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, IMoniker* pmkOther, IMoniker** ppmkPrefix) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOther, ppmkPrefix); + return ret; + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, IMoniker* pmkOther, ref IMoniker* ppmkPrefix) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkPrefixPtr = &ppmkPrefix) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOther, ppmkPrefixPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, ref IMoniker pmkOther, IMoniker** ppmkPrefix) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOtherPtr, ppmkPrefix); + } + return ret; + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, ref IMoniker pmkOther, ref IMoniker* ppmkPrefix) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + fixed (IMoniker** ppmkPrefixPtr = &ppmkPrefix) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[18])(@this, pmkOtherPtr, ppmkPrefixPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, IMoniker* pmkOther, IMoniker** ppmkRelPath) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOther, ppmkRelPath); + return ret; + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, IMoniker* pmkOther, ref IMoniker* ppmkRelPath) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkRelPathPtr = &ppmkRelPath) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOther, ppmkRelPathPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, ref IMoniker pmkOther, IMoniker** ppmkRelPath) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOtherPtr, ppmkRelPath); + } + return ret; + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, ref IMoniker pmkOther, ref IMoniker* ppmkRelPath) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkOtherPtr = &pmkOther) + { + fixed (IMoniker** ppmkRelPathPtr = &ppmkRelPath) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[19])(@this, pmkOtherPtr, ppmkRelPathPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeft, ppszDisplayName); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeft, ppszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeftPtr, ppszDisplayName); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbc, pmkToLeftPtr, ppszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeft, ppszDisplayName); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeft, ppszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeftPtr, ppszDisplayName); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char** ppszDisplayNamePtr = &ppszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[20])(@this, pbcPtr, pmkToLeftPtr, ppszDisplayNamePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOut); + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEaten, ppmkOutPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOut); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOut); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbc, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEaten, ppmkOut); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEaten, ppmkOutPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeft, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOut); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEaten, ppmkOutPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayName, pchEatenPtr, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + fixed (char* pszDisplayNamePtr = &pszDisplayName) + { + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOut); + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEaten, ppmkOutPtr); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOut); + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (IMoniker* pmkToLeftPtr = &pmkToLeft) + { + var pszDisplayNamePtr = (byte*) SilkMarshal.StringToPtr(pszDisplayName, NativeStringEncoding.UTF8); + fixed (uint* pchEatenPtr = &pchEaten) + { + fixed (IMoniker** ppmkOutPtr = &ppmkOut) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[21])(@this, pbcPtr, pmkToLeftPtr, pszDisplayNamePtr, pchEatenPtr, ppmkOutPtr); + } + } + SilkMarshal.Free((nint)pszDisplayNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsSystemMoniker(this ComPtr thisVtbl, uint* pdwMksys) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pdwMksys); + return ret; + } + + /// To be documented. + public static int IsSystemMoniker(this ComPtr thisVtbl, ref uint pdwMksys) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwMksysPtr = &pdwMksys) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[22])(@this, pdwMksysPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, Span pStm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(ref pStm.GetPinnableReference()); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, Span pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(ref pStm.GetPinnableReference(), fClearDirty); + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, Span pcbSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeMax(ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + public static int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + public static int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + public static int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToObject(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Guid* riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + public static int BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvResult = default; + return @this->BindToObject(ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span riidResult, void** ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + public static unsafe int BindToObject(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span riidResult, ref void* ppvResult) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToObject(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + public static int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + public static int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage((IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + public static int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->BindToStorage(ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Guid* riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + public static int BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObj = default; + return @this->BindToStorage(ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Guid* riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span riid, void** ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + public static unsafe int BindToStorage(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span riid, ref void* ppvObj) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->BindToStorage(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + public static int Reduce(this ComPtr thisVtbl, ComPtr pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ComPtr pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref IMoniker* ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), ref ppmkReduced); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ComPtr pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, ref ppmkToLeft, (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ComPtr pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce((IBindCtx*) pbc.Handle, dwReduceHowFar, ref ppmkToLeft, ref ppmkReduced); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, Span pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Reduce(ref pbc.GetPinnableReference(), dwReduceHowFar, ppmkToLeft, ppmkReduced); + } + + /// To be documented. + public static int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce(ref pbc, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, Span pbc, uint dwReduceHowFar, IMoniker** ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Reduce(ref pbc.GetPinnableReference(), dwReduceHowFar, ppmkToLeft, ref ppmkReduced); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, ref ComPtr ppmkToLeft, ref IMoniker* ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce(ref pbc, dwReduceHowFar, (IMoniker**) ppmkToLeft.GetAddressOf(), ref ppmkReduced); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, Span pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, IMoniker** ppmkReduced) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Reduce(ref pbc.GetPinnableReference(), dwReduceHowFar, ref ppmkToLeft, ppmkReduced); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, ref IBindCtx pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref ComPtr ppmkReduced) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Reduce(ref pbc, dwReduceHowFar, ref ppmkToLeft, (IMoniker**) ppmkReduced.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Reduce(this ComPtr thisVtbl, Span pbc, uint dwReduceHowFar, ref IMoniker* ppmkToLeft, ref IMoniker* ppmkReduced) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Reduce(ref pbc.GetPinnableReference(), dwReduceHowFar, ref ppmkToLeft, ref ppmkReduced); + } + + /// To be documented. + public static int ComposeWith(this ComPtr thisVtbl, ComPtr pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref ComPtr ppmkComposite) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ComposeWith((IMoniker*) pmkRight.Handle, fOnlyIfNotGeneric, (IMoniker**) ppmkComposite.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, ComPtr pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ComposeWith((IMoniker*) pmkRight.Handle, fOnlyIfNotGeneric, ref ppmkComposite); + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, Span pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, IMoniker** ppmkComposite) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ComposeWith(ref pmkRight.GetPinnableReference(), fOnlyIfNotGeneric, ppmkComposite); + } + + /// To be documented. + public static int ComposeWith(this ComPtr thisVtbl, ref IMoniker pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref ComPtr ppmkComposite) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ComposeWith(ref pmkRight, fOnlyIfNotGeneric, (IMoniker**) ppmkComposite.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ComposeWith(this ComPtr thisVtbl, Span pmkRight, Silk.NET.Core.Bool32 fOnlyIfNotGeneric, ref IMoniker* ppmkComposite) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ComposeWith(ref pmkRight.GetPinnableReference(), fOnlyIfNotGeneric, ref ppmkComposite); + } + + /// To be documented. + public static int Enum(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fForward, ref ComPtr ppenumMoniker) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Enum(fForward, (IEnumMoniker**) ppenumMoniker.GetAddressOf()); + } + + /// To be documented. + public static int IsEqual(this ComPtr thisVtbl, ComPtr pmkOtherMoniker) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsEqual((IMoniker*) pmkOtherMoniker.Handle); + } + + /// To be documented. + public static int IsEqual(this ComPtr thisVtbl, Span pmkOtherMoniker) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsEqual(ref pmkOtherMoniker.GetPinnableReference()); + } + + /// To be documented. + public static int Hash(this ComPtr thisVtbl, Span pdwHash) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Hash(ref pdwHash.GetPinnableReference()); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(pbc, pmkToLeft, ref pmkNewlyRunning.GetPinnableReference()); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref IMoniker pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pmkNewlyRunning); + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(pbc, ref pmkToLeft.GetPinnableReference(), pmkNewlyRunning); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, ref pmkToLeft, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(pbc, ref pmkToLeft.GetPinnableReference(), ref pmkNewlyRunning.GetPinnableReference()); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref IMoniker pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pmkNewlyRunning); + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(ref pbc.GetPinnableReference(), pmkToLeft, pmkNewlyRunning); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning(ref pbc, (IMoniker*) pmkToLeft.Handle, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(ref pbc.GetPinnableReference(), pmkToLeft, ref pmkNewlyRunning.GetPinnableReference()); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref IMoniker pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pmkNewlyRunning); + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, IMoniker* pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pmkNewlyRunning); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ComPtr pmkNewlyRunning) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning(ref pbc, ref pmkToLeft, (IMoniker*) pmkNewlyRunning.Handle); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span pmkNewlyRunning) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref pmkNewlyRunning.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, Filetime* pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(pbc, pmkToLeft, ref pFileTime.GetPinnableReference()); + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref Filetime pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(pbc, ref pmkToLeft.GetPinnableReference(), pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, Filetime* pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, ref pmkToLeft, pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(pbc, ref pmkToLeft.GetPinnableReference(), ref pFileTime.GetPinnableReference()); + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref Filetime pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(ref pbc.GetPinnableReference(), pmkToLeft, pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, Filetime* pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange(ref pbc, (IMoniker*) pmkToLeft.Handle, pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(ref pbc.GetPinnableReference(), pmkToLeft, ref pFileTime.GetPinnableReference()); + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref Filetime pFileTime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pFileTime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Filetime* pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pFileTime); + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span pFileTime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref pFileTime.GetPinnableReference()); + } + + /// To be documented. + public static int Inverse(this ComPtr thisVtbl, ref ComPtr ppmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Inverse((IMoniker**) ppmk.GetAddressOf()); + } + + /// To be documented. + public static int CommonPrefixWith(this ComPtr thisVtbl, ComPtr pmkOther, ref ComPtr ppmkPrefix) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CommonPrefixWith((IMoniker*) pmkOther.Handle, (IMoniker**) ppmkPrefix.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, ComPtr pmkOther, ref IMoniker* ppmkPrefix) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CommonPrefixWith((IMoniker*) pmkOther.Handle, ref ppmkPrefix); + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, Span pmkOther, IMoniker** ppmkPrefix) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CommonPrefixWith(ref pmkOther.GetPinnableReference(), ppmkPrefix); + } + + /// To be documented. + public static int CommonPrefixWith(this ComPtr thisVtbl, ref IMoniker pmkOther, ref ComPtr ppmkPrefix) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CommonPrefixWith(ref pmkOther, (IMoniker**) ppmkPrefix.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CommonPrefixWith(this ComPtr thisVtbl, Span pmkOther, ref IMoniker* ppmkPrefix) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CommonPrefixWith(ref pmkOther.GetPinnableReference(), ref ppmkPrefix); + } + + /// To be documented. + public static int RelativePathTo(this ComPtr thisVtbl, ComPtr pmkOther, ref ComPtr ppmkRelPath) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RelativePathTo((IMoniker*) pmkOther.Handle, (IMoniker**) ppmkRelPath.GetAddressOf()); + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, ComPtr pmkOther, ref IMoniker* ppmkRelPath) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RelativePathTo((IMoniker*) pmkOther.Handle, ref ppmkRelPath); + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, Span pmkOther, IMoniker** ppmkRelPath) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RelativePathTo(ref pmkOther.GetPinnableReference(), ppmkRelPath); + } + + /// To be documented. + public static int RelativePathTo(this ComPtr thisVtbl, ref IMoniker pmkOther, ref ComPtr ppmkRelPath) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->RelativePathTo(ref pmkOther, (IMoniker**) ppmkRelPath.GetAddressOf()); + } + + /// To be documented. + public static unsafe int RelativePathTo(this ComPtr thisVtbl, Span pmkOther, ref IMoniker* ppmkRelPath) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RelativePathTo(ref pmkOther.GetPinnableReference(), ref ppmkRelPath); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(pbc, pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, char** ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref char* ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, ref IMoniker pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(pbc, ref pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, char** ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), ref ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref char* ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, IMoniker* pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(ref pbc, pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, char** ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, ref ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref char* ppszDisplayName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref ppszDisplayName); + } + + /// To be documented. + public static int GetDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, string[] ppszDisplayNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppszDisplayName = (char**) SilkMarshal.StringArrayToPtr(ppszDisplayNameSa); + var ret = @this->GetDisplayName(ref pbc, ref pmkToLeft, ppszDisplayName); + SilkMarshal.CopyPtrToStringArray((nint) ppszDisplayName, ppszDisplayNameSa); + SilkMarshal.Free((nint) ppszDisplayName); + return ret; + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, char** ppszDisplayName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ppszDisplayName); + } + + /// To be documented. + public static unsafe int GetDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, ref char* ppszDisplayName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref ppszDisplayName); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, char* pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, ref pszDisplayName.GetPinnableReference(), pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, ref pszDisplayName.GetPinnableReference(), pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, Span pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, char* pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, char* pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, Span pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, ref pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, IBindCtx* pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(pbc, ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName((IBindCtx*) pbc.Handle, ref pmkToLeft, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, char* pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, char* pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, ref pszDisplayName.GetPinnableReference(), pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, ref pszDisplayName.GetPinnableReference(), pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, Span pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, ref pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, IMoniker* pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), pmkToLeft, pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref IMoniker* ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, (IMoniker*) pmkToLeft.Handle, pszDisplayName, ref pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, char* pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, char* pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, char* pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, char* pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, char* pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, ref pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref char pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, ref pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, Span pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref pszDisplayName.GetPinnableReference(), ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, uint* pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, pchEaten, ref ppmkOut); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, IMoniker** ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ppmkOut); + } + + /// To be documented. + public static int ParseDisplayName(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, ref uint pchEaten, ref ComPtr ppmkOut) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ParseDisplayName(ref pbc, ref pmkToLeft, pszDisplayName, ref pchEaten, (IMoniker**) ppmkOut.GetAddressOf()); + } + + /// To be documented. + public static unsafe int ParseDisplayName(this ComPtr thisVtbl, Span pbc, Span pmkToLeft, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszDisplayName, Span pchEaten, ref IMoniker* ppmkOut) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ParseDisplayName(ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), pszDisplayName, ref pchEaten.GetPinnableReference(), ref ppmkOut); + } + + /// To be documented. + public static int IsSystemMoniker(this ComPtr thisVtbl, Span pdwMksys) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsSystemMoniker(ref pdwMksys.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToObject(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToObject(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToObject(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToObject(ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToStorage(this ComPtr thisVtbl, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr BindToStorage(this ComPtr thisVtbl, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->BindToStorage(ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/OplockStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/OplockStorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..b4bf3aad16 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/OplockStorageVtblExtensions.gen.cs @@ -0,0 +1,685 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class OplockStorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riid, ppstgOpenPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpen); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, ref Guid riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppstgOpenPtr = &ppstgOpen) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, grfMode, stgfmt, grfAttrs, riidPtr, ppstgOpenPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppstgOpen = default; + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ppstgOpen); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ref ppstgOpen); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + } + + /// To be documented. + public static int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppstgOpen = default; + return @this->CreateStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, riid, ref ppstgOpen); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ppstgOpen); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ref ppstgOpen); + } + + /// To be documented. + public static int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppstgOpen = default; + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ppstgOpen); + } + + /// To be documented. + public static unsafe int CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ref ppstgOpen); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppstgOpen = default; + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ppstgOpen); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ref ppstgOpen); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, riid, ppstgOpen); + } + + /// To be documented. + public static int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppstgOpen = default; + return @this->OpenStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Guid* riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, riid, ref ppstgOpen); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ppstgOpen); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(in pwcsName.GetPinnableReference(), grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ref ppstgOpen); + } + + /// To be documented. + public static int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, out ComPtr ppstgOpen) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppstgOpen = default; + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, SilkMarshal.GuidPtrOf(), (void**) ppstgOpen.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, void** ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ppstgOpen); + } + + /// To be documented. + public static unsafe int OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs, Span riid, ref void* ppstgOpen) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, ref riid.GetPinnableReference(), ref ppstgOpen); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->OpenStorageEx(in pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr OpenStorageEx(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwcsName, uint grfMode, uint stgfmt, uint grfAttrs) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->OpenStorageEx(pwcsName, grfMode, stgfmt, grfAttrs, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistFileVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistFileVtblExtensions.gen.cs new file mode 100644 index 0000000000..310d1a32c5 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistFileVtblExtensions.gen.cs @@ -0,0 +1,312 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PersistFileVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszFileName, uint dwMode) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pszFileName, dwMode); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszFileName, uint dwMode) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszFileNamePtr = &pszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pszFileNamePtr, dwMode); + } + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFileName, uint dwMode) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszFileNamePtr = (byte*) SilkMarshal.StringToPtr(pszFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pszFileNamePtr, dwMode); + SilkMarshal.Free((nint)pszFileNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pszFileName, fRemember); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszFileNamePtr = &pszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pszFileNamePtr, fRemember); + } + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszFileNamePtr = (byte*) SilkMarshal.StringToPtr(pszFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pszFileNamePtr, fRemember); + SilkMarshal.Free((nint)pszFileNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SaveCompleted(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pszFileName); + return ret; + } + + /// To be documented. + public static int SaveCompleted(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszFileNamePtr = &pszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pszFileNamePtr); + } + return ret; + } + + /// To be documented. + public static int SaveCompleted(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszFileNamePtr = (byte*) SilkMarshal.StringToPtr(pszFileName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pszFileNamePtr); + SilkMarshal.Free((nint)pszFileNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetCurFile(this ComPtr thisVtbl, char** ppszFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppszFileName); + return ret; + } + + /// To be documented. + public static unsafe int GetCurFile(this ComPtr thisVtbl, ref char* ppszFileName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** ppszFileNamePtr = &ppszFileName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, ppszFileNamePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszFileName, uint dwMode) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(in pszFileName.GetPinnableReference(), dwMode); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszFileName, Silk.NET.Core.Bool32 fRemember) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(in pszFileName.GetPinnableReference(), fRemember); + } + + /// To be documented. + public static int SaveCompleted(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszFileName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SaveCompleted(in pszFileName.GetPinnableReference()); + } + + /// To be documented. + public static int GetCurFile(this ComPtr thisVtbl, string[] ppszFileNameSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppszFileName = (char**) SilkMarshal.StringArrayToPtr(ppszFileNameSa); + var ret = @this->GetCurFile(ppszFileName); + SilkMarshal.CopyPtrToStringArray((nint) ppszFileName, ppszFileNameSa); + SilkMarshal.Free((nint) ppszFileName); + return ret; + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..246f50f5ec --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStorageVtblExtensions.gen.cs @@ -0,0 +1,316 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PersistStorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int InitNew(this ComPtr thisVtbl, IStorage* pStg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStg); + return ret; + } + + /// To be documented. + public static int InitNew(this ComPtr thisVtbl, ref IStorage pStg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStgPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, IStorage* pStg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStg); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ref IStorage pStg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStgPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, IStorage* pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pStgSave, fSameAsLoad); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ref IStorage pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgSavePtr = &pStgSave) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pStgSavePtr, fSameAsLoad); + } + return ret; + } + + /// To be documented. + public static unsafe int SaveCompleted(this ComPtr thisVtbl, IStorage* pStgNew) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pStgNew); + return ret; + } + + /// To be documented. + public static int SaveCompleted(this ComPtr thisVtbl, ref IStorage pStgNew) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgNewPtr = &pStgNew) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pStgNewPtr); + } + return ret; + } + + /// To be documented. + public static int HandsOffStorage(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int InitNew(this ComPtr thisVtbl, ComPtr pStg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->InitNew((IStorage*) pStg.Handle); + } + + /// To be documented. + public static int InitNew(this ComPtr thisVtbl, Span pStg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitNew(ref pStg.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ComPtr pStg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Load((IStorage*) pStg.Handle); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, Span pStg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(ref pStg.GetPinnableReference()); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ComPtr pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Save((IStorage*) pStgSave.Handle, fSameAsLoad); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, Span pStgSave, Silk.NET.Core.Bool32 fSameAsLoad) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(ref pStgSave.GetPinnableReference(), fSameAsLoad); + } + + /// To be documented. + public static int SaveCompleted(this ComPtr thisVtbl, ComPtr pStgNew) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SaveCompleted((IStorage*) pStgNew.Handle); + } + + /// To be documented. + public static int SaveCompleted(this ComPtr thisVtbl, Span pStgNew) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SaveCompleted(ref pStgNew.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamVtblExtensions.gen.cs new file mode 100644 index 0000000000..615aff1cfb --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistStreamVtblExtensions.gen.cs @@ -0,0 +1,262 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PersistStreamVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSizeMax(this ComPtr thisVtbl, ulong* pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSize); + return ret; + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, ref ulong pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, Span pStm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(ref pStm.GetPinnableReference()); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, Span pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(ref pStm.GetPinnableReference(), fClearDirty); + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, Span pcbSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeMax(ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistVtblExtensions.gen.cs new file mode 100644 index 0000000000..8c67f29726 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/PersistVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class PersistVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ProcessLockVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProcessLockVtblExtensions.gen.cs new file mode 100644 index 0000000000..2496834156 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProcessLockVtblExtensions.gen.cs @@ -0,0 +1,139 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ProcessLockVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static uint AddRefOnProcess(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public static uint ReleaseRefOnProcess(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ProgressNotifyVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProgressNotifyVtblExtensions.gen.cs new file mode 100644 index 0000000000..ff5a3b8af1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ProgressNotifyVtblExtensions.gen.cs @@ -0,0 +1,130 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ProgressNotifyVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int OnProgress(this ComPtr thisVtbl, uint dwProgressCurrent, uint dwProgressMaximum, Silk.NET.Core.Bool32 fAccurate, Silk.NET.Core.Bool32 fOwner) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwProgressCurrent, dwProgressMaximum, fAccurate, fOwner); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ROTDataVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ROTDataVtblExtensions.gen.cs new file mode 100644 index 0000000000..ac88163d4d --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ROTDataVtblExtensions.gen.cs @@ -0,0 +1,226 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ROTDataVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComparisonData(this ComPtr thisVtbl, byte* pbData, uint cbMax, uint* pcbData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbData, cbMax, pcbData); + return ret; + } + + /// To be documented. + public static unsafe int GetComparisonData(this ComPtr thisVtbl, byte* pbData, uint cbMax, ref uint pcbData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbDataPtr = &pcbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbData, cbMax, pcbDataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetComparisonData(this ComPtr thisVtbl, ref byte pbData, uint cbMax, uint* pcbData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbDataPtr = &pbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbData); + } + return ret; + } + + /// To be documented. + public static int GetComparisonData(this ComPtr thisVtbl, ref byte pbData, uint cbMax, ref uint pcbData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbDataPtr = &pbData) + { + fixed (uint* pcbDataPtr = &pcbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbDataPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetComparisonData(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbData, uint cbMax, uint* pcbData) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbDataPtr = (byte*) SilkMarshal.StringToPtr(pbData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbData); + SilkMarshal.Free((nint)pbDataPtr); + return ret; + } + + /// To be documented. + public static int GetComparisonData(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbData, uint cbMax, ref uint pcbData) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbDataPtr = (byte*) SilkMarshal.StringToPtr(pbData, NativeStringEncoding.UTF8); + fixed (uint* pcbDataPtr = &pcbData) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pbDataPtr, cbMax, pcbDataPtr); + } + SilkMarshal.Free((nint)pbDataPtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetComparisonData(this ComPtr thisVtbl, byte* pbData, uint cbMax, Span pcbData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComparisonData(pbData, cbMax, ref pcbData.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetComparisonData(this ComPtr thisVtbl, Span pbData, uint cbMax, uint* pcbData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComparisonData(ref pbData.GetPinnableReference(), cbMax, pcbData); + } + + /// To be documented. + public static int GetComparisonData(this ComPtr thisVtbl, Span pbData, uint cbMax, Span pcbData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComparisonData(ref pbData.GetPinnableReference(), cbMax, ref pcbData.GetPinnableReference()); + } + + /// To be documented. + public static int GetComparisonData(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbData, uint cbMax, Span pcbData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComparisonData(pbData, cbMax, ref pcbData.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/RootStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RootStorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..97ddbd9558 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RootStorageVtblExtensions.gen.cs @@ -0,0 +1,161 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class RootStorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SwitchToFile(this ComPtr thisVtbl, char* pszFile) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszFile); + return ret; + } + + /// To be documented. + public static int SwitchToFile(this ComPtr thisVtbl, ref char pszFile) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszFilePtr = &pszFile) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszFilePtr); + } + return ret; + } + + /// To be documented. + public static int SwitchToFile(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pszFile) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszFilePtr = (byte*) SilkMarshal.StringToPtr(pszFile, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pszFilePtr); + SilkMarshal.Free((nint)pszFilePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int SwitchToFile(this ComPtr thisVtbl, Span pszFile) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SwitchToFile(ref pszFile.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/RunnableObjectVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RunnableObjectVtblExtensions.gen.cs new file mode 100644 index 0000000000..3fb1aa59d7 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RunnableObjectVtblExtensions.gen.cs @@ -0,0 +1,214 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class RunnableObjectVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetRunningClass(this ComPtr thisVtbl, Guid* lpClsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpClsid); + return ret; + } + + /// To be documented. + public static int GetRunningClass(this ComPtr thisVtbl, ref Guid lpClsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* lpClsidPtr = &lpClsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, lpClsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Run(this ComPtr thisVtbl, IBindCtx* pbc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pbc); + return ret; + } + + /// To be documented. + public static int Run(this ComPtr thisVtbl, ref IBindCtx pbc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pbcPtr); + } + return ret; + } + + /// To be documented. + public static Silk.NET.Core.Bool32 IsRunning(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + Silk.NET.Core.Bool32 ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static int LockRunning(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fLock, Silk.NET.Core.Bool32 fLastUnlockCloses) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, fLock, fLastUnlockCloses); + return ret; + } + + /// To be documented. + public static int SetContainedObject(this ComPtr thisVtbl, Silk.NET.Core.Bool32 fContained) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, fContained); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetRunningClass(this ComPtr thisVtbl, Span lpClsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetRunningClass(ref lpClsid.GetPinnableReference()); + } + + /// To be documented. + public static int Run(this ComPtr thisVtbl, ComPtr pbc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Run((IBindCtx*) pbc.Handle); + } + + /// To be documented. + public static int Run(this ComPtr thisVtbl, Span pbc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Run(ref pbc.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/RunningObjectTableVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RunningObjectTableVtblExtensions.gen.cs new file mode 100644 index 0000000000..cdb8f44105 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RunningObjectTableVtblExtensions.gen.cs @@ -0,0 +1,613 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class RunningObjectTableVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, IMoniker* pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectName, pdwRegister); + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, IMoniker* pmkObjectName, ref uint pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectName, pdwRegisterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, ref IMoniker pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectNamePtr, pdwRegister); + } + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, ref IMoniker pmkObjectName, ref uint pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObject, pmkObjectNamePtr, pdwRegisterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, IMoniker* pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectName, pdwRegister); + } + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, IMoniker* pmkObjectName, ref uint pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectName, pdwRegisterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ref IMoniker pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectNamePtr, pdwRegister); + } + } + return ret; + } + + /// To be documented. + public static int Register(this ComPtr thisVtbl, uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ref IMoniker pmkObjectName, ref uint pdwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* punkObjectPtr = &punkObject) + { + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (uint* pdwRegisterPtr = &pdwRegister) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, grfFlags, punkObjectPtr, pmkObjectNamePtr, pdwRegisterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int Revoke(this ComPtr thisVtbl, uint dwRegister) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwRegister); + return ret; + } + + /// To be documented. + public static unsafe int IsRunning(this ComPtr thisVtbl, IMoniker* pmkObjectName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkObjectName); + return ret; + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ref IMoniker pmkObjectName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pmkObjectNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, IMoniker* pmkObjectName, Silk.NET.Core.Native.IUnknown** ppunkObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectName, ppunkObject); + return ret; + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, IMoniker* pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppunkObjectPtr = &ppunkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectName, ppunkObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, ref IMoniker pmkObjectName, Silk.NET.Core.Native.IUnknown** ppunkObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectNamePtr, ppunkObject); + } + return ret; + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, ref IMoniker pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (Silk.NET.Core.Native.IUnknown** ppunkObjectPtr = &ppunkObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pmkObjectNamePtr, ppunkObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int NoteChangeTime(this ComPtr thisVtbl, uint dwRegister, Filetime* pfiletime) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, dwRegister, pfiletime); + return ret; + } + + /// To be documented. + public static int NoteChangeTime(this ComPtr thisVtbl, uint dwRegister, ref Filetime pfiletime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pfiletimePtr = &pfiletime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, dwRegister, pfiletimePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IMoniker* pmkObjectName, Filetime* pfiletime) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectName, pfiletime); + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IMoniker* pmkObjectName, ref Filetime pfiletime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pfiletimePtr = &pfiletime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectName, pfiletimePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ref IMoniker pmkObjectName, Filetime* pfiletime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectNamePtr, pfiletime); + } + return ret; + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, ref IMoniker pmkObjectName, ref Filetime pfiletime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IMoniker* pmkObjectNamePtr = &pmkObjectName) + { + fixed (Filetime* pfiletimePtr = &pfiletime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pmkObjectNamePtr, pfiletimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int EnumRunning(this ComPtr thisVtbl, IEnumMoniker** ppenumMoniker) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppenumMoniker); + return ret; + } + + /// To be documented. + public static unsafe int EnumRunning(this ComPtr thisVtbl, ref IEnumMoniker* ppenumMoniker) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumMoniker** ppenumMonikerPtr = &ppenumMoniker) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, ppenumMonikerPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, ComPtr punkObject, ComPtr pmkObjectName, uint* pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, (IMoniker*) pmkObjectName.Handle, pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, IMoniker* pmkObjectName, Span pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, punkObject, pmkObjectName, ref pdwRegister.GetPinnableReference()); + } + + /// To be documented. + public static int Register(this ComPtr thisVtbl, uint grfFlags, ComPtr punkObject, ComPtr pmkObjectName, ref uint pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, (IMoniker*) pmkObjectName.Handle, ref pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, Span pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, punkObject, ref pmkObjectName.GetPinnableReference(), pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, ComPtr punkObject, ref IMoniker pmkObjectName, uint* pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, ref pmkObjectName, pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Silk.NET.Core.Native.IUnknown* punkObject, Span pmkObjectName, Span pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, punkObject, ref pmkObjectName.GetPinnableReference(), ref pdwRegister.GetPinnableReference()); + } + + /// To be documented. + public static int Register(this ComPtr thisVtbl, uint grfFlags, ComPtr punkObject, ref IMoniker pmkObjectName, ref uint pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Register(grfFlags, (Silk.NET.Core.Native.IUnknown*) punkObject.Handle, ref pmkObjectName, ref pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Span punkObject, IMoniker* pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, ref punkObject.GetPinnableReference(), pmkObjectName, pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ComPtr pmkObjectName, uint* pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Register(grfFlags, ref punkObject, (IMoniker*) pmkObjectName.Handle, pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Span punkObject, IMoniker* pmkObjectName, Span pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, ref punkObject.GetPinnableReference(), pmkObjectName, ref pdwRegister.GetPinnableReference()); + } + + /// To be documented. + public static int Register(this ComPtr thisVtbl, uint grfFlags, ref Silk.NET.Core.Native.IUnknown punkObject, ComPtr pmkObjectName, ref uint pdwRegister) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Register(grfFlags, ref punkObject, (IMoniker*) pmkObjectName.Handle, ref pdwRegister); + } + + /// To be documented. + public static unsafe int Register(this ComPtr thisVtbl, uint grfFlags, Span punkObject, Span pmkObjectName, uint* pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, ref punkObject.GetPinnableReference(), ref pmkObjectName.GetPinnableReference(), pdwRegister); + } + + /// To be documented. + public static int Register(this ComPtr thisVtbl, uint grfFlags, Span punkObject, Span pmkObjectName, Span pdwRegister) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Register(grfFlags, ref punkObject.GetPinnableReference(), ref pmkObjectName.GetPinnableReference(), ref pdwRegister.GetPinnableReference()); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, ComPtr pmkObjectName) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->IsRunning((IMoniker*) pmkObjectName.Handle); + } + + /// To be documented. + public static int IsRunning(this ComPtr thisVtbl, Span pmkObjectName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsRunning(ref pmkObjectName.GetPinnableReference()); + } + + /// To be documented. + public static int GetObjectA(this ComPtr thisVtbl, ComPtr pmkObjectName, ref ComPtr ppunkObject) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetObjectA((IMoniker*) pmkObjectName.Handle, (Silk.NET.Core.Native.IUnknown**) ppunkObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, ComPtr pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetObjectA((IMoniker*) pmkObjectName.Handle, ref ppunkObject); + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, Span pmkObjectName, Silk.NET.Core.Native.IUnknown** ppunkObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetObjectA(ref pmkObjectName.GetPinnableReference(), ppunkObject); + } + + /// To be documented. + public static int GetObjectA(this ComPtr thisVtbl, ref IMoniker pmkObjectName, ref ComPtr ppunkObject) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetObjectA(ref pmkObjectName, (Silk.NET.Core.Native.IUnknown**) ppunkObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetObjectA(this ComPtr thisVtbl, Span pmkObjectName, ref Silk.NET.Core.Native.IUnknown* ppunkObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetObjectA(ref pmkObjectName.GetPinnableReference(), ref ppunkObject); + } + + /// To be documented. + public static int NoteChangeTime(this ComPtr thisVtbl, uint dwRegister, Span pfiletime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->NoteChangeTime(dwRegister, ref pfiletime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, ComPtr pmkObjectName, Filetime* pfiletime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange((IMoniker*) pmkObjectName.Handle, pfiletime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, IMoniker* pmkObjectName, Span pfiletime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(pmkObjectName, ref pfiletime.GetPinnableReference()); + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, ComPtr pmkObjectName, ref Filetime pfiletime) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetTimeOfLastChange((IMoniker*) pmkObjectName.Handle, ref pfiletime); + } + + /// To be documented. + public static unsafe int GetTimeOfLastChange(this ComPtr thisVtbl, Span pmkObjectName, Filetime* pfiletime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(ref pmkObjectName.GetPinnableReference(), pfiletime); + } + + /// To be documented. + public static int GetTimeOfLastChange(this ComPtr thisVtbl, Span pmkObjectName, Span pfiletime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTimeOfLastChange(ref pmkObjectName.GetPinnableReference(), ref pfiletime.GetPinnableReference()); + } + + /// To be documented. + public static int EnumRunning(this ComPtr thisVtbl, ref ComPtr ppenumMoniker) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumRunning((IEnumMoniker**) ppenumMoniker.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/StorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/StorageVtblExtensions.gen.cs new file mode 100644 index 0000000000..e7f6616c03 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/StorageVtblExtensions.gen.cs @@ -0,0 +1,2968 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class StorageVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, reserved1, reserved2, ppstm); + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsName, grfMode, reserved1, reserved2, ppstmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstm); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstmPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstm); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstmPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1, grfMode, reserved2, ppstm); + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1, grfMode, reserved2, ppstmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* reserved1Ptr = &reserved1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1Ptr, grfMode, reserved2, ppstm); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* reserved1Ptr = &reserved1) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsName, reserved1Ptr, grfMode, reserved2, ppstmPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstm); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstmPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void* reserved1Ptr = &reserved1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstm); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (void* reserved1Ptr = &reserved1) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstmPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstm); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1, grfMode, reserved2, ppstmPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (void* reserved1Ptr = &reserved1) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstm); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (void* reserved1Ptr = &reserved1) + { + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pwcsNamePtr, reserved1Ptr, grfMode, reserved2, ppstmPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsName, grfMode, reserved1, reserved2, ppstg); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsName, grfMode, reserved1, reserved2, ppstgPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstg); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstg); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pwcsNamePtr, grfMode, reserved1, reserved2, ppstgPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstgPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExcludePtr, reserved, ppstg); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriority, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstg); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstg); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsName, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstg); + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstgPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstg); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstg); + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstgPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstg); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExclude, reserved, ppstgPtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstg); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriority, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstg); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExclude, reserved, ppstgPtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstg); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgPriorityPtr = &pstgPriority) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage** ppstgPtr = &ppstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pwcsNamePtr, pstgPriorityPtr, grfMode, snbExcludePtr, reserved, ppstgPtr); + } + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExclude, pstgDest); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExclude, pstgDestPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExcludePtr, pstgDest); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExclude, snbExcludePtr, pstgDestPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExclude, pstgDest); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExclude, pstgDestPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + fixed (char** snbExcludePtr = &snbExclude) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExcludePtr, pstgDest); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rgiidExcludePtr = &rgiidExclude) + { + fixed (char** snbExcludePtr = &snbExclude) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, ciidExclude, rgiidExcludePtr, snbExcludePtr, pstgDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDest, pwcsNewName, grfFlags); + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDest, pwcsNewNamePtr, grfFlags); + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDest, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDestPtr, pwcsNewName, grfFlags); + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDestPtr, pwcsNewNamePtr, grfFlags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pstgDestPtr = &pstgDest) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsName, pstgDestPtr, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewName, grfFlags); + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewName, grfFlags); + } + } + return ret; + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + } + } + } + return ret; + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (IStorage* pstgDestPtr = &pstgDest) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewName, grfFlags); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDest, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgDestPtr = &pstgDest) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewName, grfFlags); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgDestPtr = &pstgDest) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (IStorage* pstgDestPtr = &pstgDest) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[8])(@this, pwcsNamePtr, pstgDestPtr, pwcsNewNamePtr, grfFlags); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static int Commit(this ComPtr thisVtbl, uint grfCommitFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, grfCommitFlags); + return ret; + } + + /// To be documented. + public static int Revert(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[10])(@this); + return ret; + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, void* reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2, reserved3, ppenum); + return ret; + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IEnumSTATSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2, reserved3, ppenumPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, ref T0 reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* reserved2Ptr = &reserved2) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2Ptr, reserved3, ppenum); + } + return ret; + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* reserved2Ptr = &reserved2) + { + fixed (IEnumSTATSTG** ppenumPtr = &ppenum) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[11])(@this, reserved1, reserved2Ptr, reserved3, ppenumPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DestroyElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pwcsName); + return ret; + } + + /// To be documented. + public static int DestroyElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pwcsNamePtr); + } + return ret; + } + + /// To be documented. + public static int DestroyElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[12])(@this, pwcsNamePtr); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldName, pwcsNewName); + return ret; + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldName, pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldName, pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNewNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsOldNamePtr = &pwcsOldName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewName); + } + return ret; + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsOldNamePtr = &pwcsOldName) + { + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + } + } + return ret; + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsOldNamePtr = &pwcsOldName) + { + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNewNamePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsOldNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsOldName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewName); + SilkMarshal.Free((nint)pwcsOldNamePtr); + return ret; + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsOldNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsOldName, NativeStringEncoding.UTF8); + fixed (char* pwcsNewNamePtr = &pwcsNewName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + } + SilkMarshal.Free((nint)pwcsOldNamePtr); + return ret; + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsOldNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsOldName, NativeStringEncoding.UTF8); + var pwcsNewNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsNewName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[13])(@this, pwcsOldNamePtr, pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsNewNamePtr); + SilkMarshal.Free((nint)pwcsOldNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patime, pmtime); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patime, pmtimePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patimePtr, pmtime); + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctime, patimePtr, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patime, pmtime); + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patime, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patimePtr, pmtime); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsName, pctimePtr, patimePtr, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtime); + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtimePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtime); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtime); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtimePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtime); + } + } + } + return ret; + } + + /// To be documented. + public static int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pwcsNamePtr = &pwcsName) + { + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtimePtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtime); + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patime, pmtimePtr); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtime); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctime, patimePtr, pmtimePtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtime); + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patime, pmtimePtr); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtime); + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Filetime pmtime) + { + var @this = thisVtbl.Handle; + int ret = default; + var pwcsNamePtr = (byte*) SilkMarshal.StringToPtr(pwcsName, NativeStringEncoding.UTF8); + fixed (Filetime* pctimePtr = &pctime) + { + fixed (Filetime* patimePtr = &patime) + { + fixed (Filetime* pmtimePtr = &pmtime) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[14])(@this, pwcsNamePtr, pctimePtr, patimePtr, pmtimePtr); + } + } + } + SilkMarshal.Free((nint)pwcsNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int SetClass(this ComPtr thisVtbl, Guid* clsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, clsid); + return ret; + } + + /// To be documented. + public static int SetClass(this ComPtr thisVtbl, ref Guid clsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidPtr = &clsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[15])(@this, clsidPtr); + } + return ret; + } + + /// To be documented. + public static int SetStateBits(this ComPtr thisVtbl, uint grfStateBits, uint grfMask) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[16])(@this, grfStateBits, grfMask); + return ret; + } + + /// To be documented. + public static unsafe int Stat(this ComPtr thisVtbl, STATSTG* pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pstatstg, grfStatFlag); + return ret; + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, ref STATSTG pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (STATSTG* pstatstgPtr = &pstatstg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[17])(@this, pstatstgPtr, grfStatFlag); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStream(pwcsName, grfMode, reserved1, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint reserved1, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStream(in pwcsName.GetPinnableReference(), grfMode, reserved1, reserved2, ppstm); + } + + /// To be documented. + public static int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStream(in pwcsName, grfMode, reserved1, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint reserved1, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStream(in pwcsName.GetPinnableReference(), grfMode, reserved1, reserved2, ref ppstm); + } + + /// To be documented. + public static int CreateStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStream(pwcsName, grfMode, reserved1, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStream(pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStream(pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(in pwcsName.GetPinnableReference(), reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStream(in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(in pwcsName.GetPinnableReference(), reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(in pwcsName.GetPinnableReference(), ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + public static int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStream(in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(in pwcsName.GetPinnableReference(), ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStream(pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + public static int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStream(pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStream(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStream(pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStorage(pwcsName, grfMode, reserved1, reserved2, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint reserved1, uint reserved2, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorage(in pwcsName.GetPinnableReference(), grfMode, reserved1, reserved2, ppstg); + } + + /// To be documented. + public static int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStorage(in pwcsName, grfMode, reserved1, reserved2, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint grfMode, uint reserved1, uint reserved2, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateStorage(in pwcsName.GetPinnableReference(), grfMode, reserved1, reserved2, ref ppstg); + } + + /// To be documented. + public static int CreateStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint grfMode, uint reserved1, uint reserved2, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStorage(pwcsName, grfMode, reserved1, reserved2, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, ref snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), pstgPriority, grfMode, snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), pstgPriority, grfMode, ref snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), pstgPriority, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), ref pstgPriority.GetPinnableReference(), grfMode, snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), ref pstgPriority.GetPinnableReference(), grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), ref pstgPriority.GetPinnableReference(), grfMode, ref snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(in pwcsName, ref pstgPriority, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(in pwcsName.GetPinnableReference(), ref pstgPriority.GetPinnableReference(), grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, (IStorage*) pstgPriority.Handle, grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgPriority, uint grfMode, char** snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, string[] snbExcludeSa, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, snbExclude, reserved, ref ppstg); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgPriority, uint grfMode, char** snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, IStorage** ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, ref snbExclude, reserved, ppstg); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref IStorage pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref ComPtr ppstg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority, grfMode, ref snbExclude, reserved, (IStorage**) ppstg.GetAddressOf()); + } + + /// To be documented. + public static unsafe int OpenStorage(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgPriority, uint grfMode, ref char* snbExclude, uint reserved, ref IStorage* ppstg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OpenStorage(pwcsName, ref pstgPriority.GetPinnableReference(), grfMode, ref snbExclude, reserved, ref ppstg); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo(ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public static int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = @this->CopyTo(ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, pstgDest, in pwcsNewName.GetPinnableReference(), grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, in pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, ref pstgDest.GetPinnableReference(), pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, ref pstgDest.GetPinnableReference(), in pwcsNewName.GetPinnableReference(), grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, ref pstgDest.GetPinnableReference(), pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(in pwcsName.GetPinnableReference(), pstgDest, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(in pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(in pwcsName.GetPinnableReference(), pstgDest, in pwcsNewName.GetPinnableReference(), grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(in pwcsName, (IStorage*) pstgDest.Handle, in pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(in pwcsName.GetPinnableReference(), pstgDest, pwcsNewName, grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(in pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(in pwcsName.GetPinnableReference(), ref pstgDest.GetPinnableReference(), pwcsNewName, grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(in pwcsName.GetPinnableReference(), ref pstgDest.GetPinnableReference(), in pwcsNewName.GetPinnableReference(), grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(in pwcsName.GetPinnableReference(), ref pstgDest.GetPinnableReference(), pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, IStorage* pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, pstgDest, in pwcsNewName.GetPinnableReference(), grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, in pwcsNewName, grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ComPtr pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MoveElementTo(pwcsName, (IStorage*) pstgDest.Handle, pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, ref pstgDest.GetPinnableReference(), pwcsNewName, grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, ref pstgDest.GetPinnableReference(), in pwcsNewName.GetPinnableReference(), grfFlags); + } + + /// To be documented. + public static int MoveElementTo(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span pstgDest, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName, uint grfFlags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MoveElementTo(pwcsName, ref pstgDest.GetPinnableReference(), pwcsNewName, grfFlags); + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumElements(reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->EnumElements(reserved1, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + public static int EnumElements(this ComPtr thisVtbl, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->EnumElements(reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + public static unsafe int EnumElements(this ComPtr thisVtbl, uint reserved1, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->EnumElements(reserved1, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + public static int DestroyElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DestroyElement(in pwcsName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RenameElement(pwcsOldName, in pwcsNewName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsNewName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RenameElement(in pwcsOldName.GetPinnableReference(), pwcsNewName); + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RenameElement(in pwcsOldName.GetPinnableReference(), in pwcsNewName.GetPinnableReference()); + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsNewName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RenameElement(in pwcsOldName.GetPinnableReference(), pwcsNewName); + } + + /// To be documented. + public static int RenameElement(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsOldName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsNewName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RenameElement(pwcsOldName, in pwcsNewName.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, pctime, patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, pctime, in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, pctime, in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), patime, pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), pctime, patime, pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), pctime, patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), pctime, in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), pctime, in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), in pctime.GetPinnableReference(), patime, pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), in pctime.GetPinnableReference(), patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), in pctime.GetPinnableReference(), in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(in pwcsName.GetPinnableReference(), in pctime.GetPinnableReference(), in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, pctime, patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, pctime, in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, pctime, in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), patime, pmtime); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), patime, in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Filetime* pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), in patime.GetPinnableReference(), pmtime); + } + + /// To be documented. + public static int SetElementTimes(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pctime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan patime, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pmtime) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetElementTimes(pwcsName, in pctime.GetPinnableReference(), in patime.GetPinnableReference(), in pmtime.GetPinnableReference()); + } + + /// To be documented. + public static int SetClass(this ComPtr thisVtbl, Span clsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetClass(ref clsid.GetPinnableReference()); + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, Span pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Stat(ref pstatstg.GetPinnableReference(), grfStatFlag); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs new file mode 100644 index 0000000000..08a5a7c1fc --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs @@ -0,0 +1,393 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class SurrogateServiceVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, IProcessLock* pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLock, pfApplicationAware); + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, IProcessLock* pProcessLock, ref int pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLock, pfApplicationAwarePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, ref IProcessLock pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLockPtr, pfApplicationAware); + } + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, ref IProcessLock pProcessLock, ref int pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessID, pProcessLockPtr, pfApplicationAwarePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, ref Guid rguidProcessID, IProcessLock* pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLock, pfApplicationAware); + } + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, ref Guid rguidProcessID, IProcessLock* pProcessLock, ref int pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLock, pfApplicationAwarePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, ref Guid rguidProcessID, ref IProcessLock pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLockPtr, pfApplicationAware); + } + } + return ret; + } + + /// To be documented. + public static int Init(this ComPtr thisVtbl, ref Guid rguidProcessID, ref IProcessLock pProcessLock, ref int pfApplicationAware) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidProcessIDPtr = &rguidProcessID) + { + fixed (IProcessLock* pProcessLockPtr = &pProcessLock) + { + fixed (int* pfApplicationAwarePtr = &pfApplicationAware) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rguidProcessIDPtr, pProcessLockPtr, pfApplicationAwarePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ApplicationLaunch(this ComPtr thisVtbl, Guid* rguidApplID, TagApplicationType appType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplID, appType); + return ret; + } + + /// To be documented. + public static int ApplicationLaunch(this ComPtr thisVtbl, ref Guid rguidApplID, TagApplicationType appType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidApplIDPtr = &rguidApplID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplIDPtr, appType); + } + return ret; + } + + /// To be documented. + public static unsafe int ApplicationFree(this ComPtr thisVtbl, Guid* rguidApplID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rguidApplID); + return ret; + } + + /// To be documented. + public static int ApplicationFree(this ComPtr thisVtbl, ref Guid rguidApplID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rguidApplIDPtr = &rguidApplID) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, rguidApplIDPtr); + } + return ret; + } + + /// To be documented. + public static int CatalogRefresh(this ComPtr thisVtbl, uint ulReserved) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, ulReserved); + return ret; + } + + /// To be documented. + public static int ProcessShutdown(this ComPtr thisVtbl, TagShutdownType shutdownType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, shutdownType); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, ComPtr pProcessLock, int* pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Init(rguidProcessID, (IProcessLock*) pProcessLock.Handle, pfApplicationAware); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, IProcessLock* pProcessLock, Span pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(rguidProcessID, pProcessLock, ref pfApplicationAware.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, ComPtr pProcessLock, ref int pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Init(rguidProcessID, (IProcessLock*) pProcessLock.Handle, ref pfApplicationAware); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, Span pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(rguidProcessID, ref pProcessLock.GetPinnableReference(), pfApplicationAware); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Guid* rguidProcessID, Span pProcessLock, Span pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(rguidProcessID, ref pProcessLock.GetPinnableReference(), ref pfApplicationAware.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Span rguidProcessID, IProcessLock* pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(ref rguidProcessID.GetPinnableReference(), pProcessLock, pfApplicationAware); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, ref Guid rguidProcessID, ComPtr pProcessLock, int* pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Init(ref rguidProcessID, (IProcessLock*) pProcessLock.Handle, pfApplicationAware); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Span rguidProcessID, IProcessLock* pProcessLock, Span pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(ref rguidProcessID.GetPinnableReference(), pProcessLock, ref pfApplicationAware.GetPinnableReference()); + } + + /// To be documented. + public static int Init(this ComPtr thisVtbl, ref Guid rguidProcessID, ComPtr pProcessLock, ref int pfApplicationAware) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Init(ref rguidProcessID, (IProcessLock*) pProcessLock.Handle, ref pfApplicationAware); + } + + /// To be documented. + public static unsafe int Init(this ComPtr thisVtbl, Span rguidProcessID, Span pProcessLock, int* pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(ref rguidProcessID.GetPinnableReference(), ref pProcessLock.GetPinnableReference(), pfApplicationAware); + } + + /// To be documented. + public static int Init(this ComPtr thisVtbl, Span rguidProcessID, Span pProcessLock, Span pfApplicationAware) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Init(ref rguidProcessID.GetPinnableReference(), ref pProcessLock.GetPinnableReference(), ref pfApplicationAware.GetPinnableReference()); + } + + /// To be documented. + public static int ApplicationLaunch(this ComPtr thisVtbl, Span rguidApplID, TagApplicationType appType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ApplicationLaunch(ref rguidApplID.GetPinnableReference(), appType); + } + + /// To be documented. + public static int ApplicationFree(this ComPtr thisVtbl, Span rguidApplID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ApplicationFree(ref rguidApplID.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs new file mode 100644 index 0000000000..eb09885826 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagBIND_OPTS")] + public unsafe partial struct TagBINDOPTS + { + public TagBINDOPTS + ( + uint? cbStruct = null, + uint? grfFlags = null, + uint? grfMode = null, + uint? dwTickCountDeadline = null + ) : this() + { + if (cbStruct is not null) + { + CbStruct = cbStruct.Value; + } + + if (grfFlags is not null) + { + GrfFlags = grfFlags.Value; + } + + if (grfMode is not null) + { + GrfMode = grfMode.Value; + } + + if (dwTickCountDeadline is not null) + { + DwTickCountDeadline = dwTickCountDeadline.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "cbStruct")] + public uint CbStruct; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "grfFlags")] + public uint GrfFlags; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "grfMode")] + public uint GrfMode; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwTickCountDeadline")] + public uint DwTickCountDeadline; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs new file mode 100644 index 0000000000..5556d88dac --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs @@ -0,0 +1,116 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagBIND_OPTS2")] + public unsafe partial struct TagBINDOPTS2 + { + public TagBINDOPTS2 + ( + uint? cbStruct = null, + uint? grfFlags = null, + uint? grfMode = null, + uint? dwTickCountDeadline = null, + uint? dwTrackFlags = null, + uint? dwClassContext = null, + uint? locale = null, + Coserverinfo* pServerInfo = null + ) : this() + { + if (cbStruct is not null) + { + CbStruct = cbStruct.Value; + } + + if (grfFlags is not null) + { + GrfFlags = grfFlags.Value; + } + + if (grfMode is not null) + { + GrfMode = grfMode.Value; + } + + if (dwTickCountDeadline is not null) + { + DwTickCountDeadline = dwTickCountDeadline.Value; + } + + if (dwTrackFlags is not null) + { + DwTrackFlags = dwTrackFlags.Value; + } + + if (dwClassContext is not null) + { + DwClassContext = dwClassContext.Value; + } + + if (locale is not null) + { + Locale = locale.Value; + } + + if (pServerInfo is not null) + { + PServerInfo = pServerInfo; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "cbStruct")] + public uint CbStruct; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "grfFlags")] + public uint GrfFlags; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "grfMode")] + public uint GrfMode; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwTickCountDeadline")] + public uint DwTickCountDeadline; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwTrackFlags")] + public uint DwTrackFlags; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwClassContext")] + public uint DwClassContext; + + [NativeName("Type", "LCID")] + [NativeName("Type.Name", "LCID")] + [NativeName("Name", "locale")] + public uint Locale; + + [NativeName("Type", "COSERVERINFO *")] + [NativeName("Type.Name", "COSERVERINFO *")] + [NativeName("Name", "pServerInfo")] + public Coserverinfo* PServerInfo; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs new file mode 100644 index 0000000000..32845dd58b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagBIND_OPTS3")] + public unsafe partial struct TagBINDOPTS3 + { + public TagBINDOPTS3 + ( + uint? dwTrackFlags = null, + uint? dwClassContext = null, + uint? locale = null, + Coserverinfo* pServerInfo = null, + nint? hwnd = null + ) : this() + { + if (dwTrackFlags is not null) + { + DwTrackFlags = dwTrackFlags.Value; + } + + if (dwClassContext is not null) + { + DwClassContext = dwClassContext.Value; + } + + if (locale is not null) + { + Locale = locale.Value; + } + + if (pServerInfo is not null) + { + PServerInfo = pServerInfo; + } + + if (hwnd is not null) + { + Hwnd = hwnd.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwTrackFlags")] + public uint DwTrackFlags; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwClassContext")] + public uint DwClassContext; + + [NativeName("Type", "LCID")] + [NativeName("Type.Name", "LCID")] + [NativeName("Name", "locale")] + public uint Locale; + + [NativeName("Type", "COSERVERINFO *")] + [NativeName("Type.Name", "COSERVERINFO *")] + [NativeName("Name", "pServerInfo")] + public Coserverinfo* PServerInfo; + + [NativeName("Type", "HWND")] + [NativeName("Type.Name", "HWND")] + [NativeName("Name", "hwnd")] + public nint Hwnd; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs new file mode 100644 index 0000000000..3e76f9f321 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs @@ -0,0 +1,87 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagDVTARGETDEVICE")] + public unsafe partial struct TagDVTARGETDEVICE + { + public TagDVTARGETDEVICE + ( + uint? tdSize = null, + ushort? tdDriverNameOffset = null, + ushort? tdDeviceNameOffset = null, + ushort? tdPortNameOffset = null, + ushort? tdExtDevmodeOffset = null + ) : this() + { + if (tdSize is not null) + { + TdSize = tdSize.Value; + } + + if (tdDriverNameOffset is not null) + { + TdDriverNameOffset = tdDriverNameOffset.Value; + } + + if (tdDeviceNameOffset is not null) + { + TdDeviceNameOffset = tdDeviceNameOffset.Value; + } + + if (tdPortNameOffset is not null) + { + TdPortNameOffset = tdPortNameOffset.Value; + } + + if (tdExtDevmodeOffset is not null) + { + TdExtDevmodeOffset = tdExtDevmodeOffset.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "tdSize")] + public uint TdSize; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "tdDriverNameOffset")] + public ushort TdDriverNameOffset; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "tdDeviceNameOffset")] + public ushort TdDeviceNameOffset; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "tdPortNameOffset")] + public ushort TdPortNameOffset; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "tdExtDevmodeOffset")] + public ushort TdExtDevmodeOffset; + [NativeName("Type", "BYTE[1]")] + [NativeName("Type.Name", "BYTE[1]")] + [NativeName("Name", "tdData")] + public fixed byte TdData[1]; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs new file mode 100644 index 0000000000..ad5310e036 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagFORMATETC")] + public unsafe partial struct TagFORMATETC + { + public TagFORMATETC + ( + ushort? cfFormat = null, + TagDVTARGETDEVICE* ptd = null, + uint? dwAspect = null, + int? lindex = null, + uint? tymed = null + ) : this() + { + if (cfFormat is not null) + { + CfFormat = cfFormat.Value; + } + + if (ptd is not null) + { + Ptd = ptd; + } + + if (dwAspect is not null) + { + DwAspect = dwAspect.Value; + } + + if (lindex is not null) + { + Lindex = lindex.Value; + } + + if (tymed is not null) + { + Tymed = tymed.Value; + } + } + + + [NativeName("Type", "CLIPFORMAT")] + [NativeName("Type.Name", "CLIPFORMAT")] + [NativeName("Name", "cfFormat")] + public ushort CfFormat; + + [NativeName("Type", "DVTARGETDEVICE *")] + [NativeName("Type.Name", "DVTARGETDEVICE *")] + [NativeName("Name", "ptd")] + public TagDVTARGETDEVICE* Ptd; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwAspect")] + public uint DwAspect; + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "lindex")] + public int Lindex; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "tymed")] + public uint Tymed; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs new file mode 100644 index 0000000000..8add3f56d1 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagINTERFACEINFO")] + public unsafe partial struct TagINTERFACEINFO + { + public TagINTERFACEINFO + ( + Silk.NET.Core.Native.IUnknown* pUnk = null, + Guid? iid = null, + ushort? wMethod = null + ) : this() + { + if (pUnk is not null) + { + PUnk = pUnk; + } + + if (iid is not null) + { + Iid = iid.Value; + } + + if (wMethod is not null) + { + WMethod = wMethod.Value; + } + } + + + [NativeName("Type", "IUnknown *")] + [NativeName("Type.Name", "IUnknown *")] + [NativeName("Name", "pUnk")] + public Silk.NET.Core.Native.IUnknown* PUnk; + + [NativeName("Type", "IID")] + [NativeName("Type.Name", "IID")] + [NativeName("Name", "iid")] + public Guid Iid; + + [NativeName("Type", "WORD")] + [NativeName("Type.Name", "WORD")] + [NativeName("Name", "wMethod")] + public ushort WMethod; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs new file mode 100644 index 0000000000..3da2687a55 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs @@ -0,0 +1,55 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagRemSNB")] + public unsafe partial struct TagRemSNB + { + public TagRemSNB + ( + uint? ulCntStr = null, + uint? ulCntChar = null + ) : this() + { + if (ulCntStr is not null) + { + UlCntStr = ulCntStr.Value; + } + + if (ulCntChar is not null) + { + UlCntChar = ulCntChar.Value; + } + } + + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "ulCntStr")] + public uint UlCntStr; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "ulCntChar")] + public uint UlCntChar; + [NativeName("Type", "OLECHAR[1]")] + [NativeName("Type.Name", "OLECHAR[1]")] + [NativeName("Name", "rgString")] + public fixed char RgString[1]; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs new file mode 100644 index 0000000000..dc63dd651a --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs @@ -0,0 +1,87 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagRemSTGMEDIUM")] + public unsafe partial struct TagRemSTGMEDIUM + { + public TagRemSTGMEDIUM + ( + uint? tymed = null, + uint? dwHandleType = null, + uint? pData = null, + uint? pUnkForRelease = null, + uint? cbData = null + ) : this() + { + if (tymed is not null) + { + Tymed = tymed.Value; + } + + if (dwHandleType is not null) + { + DwHandleType = dwHandleType.Value; + } + + if (pData is not null) + { + PData = pData.Value; + } + + if (pUnkForRelease is not null) + { + PUnkForRelease = pUnkForRelease.Value; + } + + if (cbData is not null) + { + CbData = cbData.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "tymed")] + public uint Tymed; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwHandleType")] + public uint DwHandleType; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "pData")] + public uint PData; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "pUnkForRelease")] + public uint PUnkForRelease; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "cbData")] + public uint CbData; + [NativeName("Type", "byte[1]")] + [NativeName("Type.Name", "byte[1]")] + [NativeName("Name", "data")] + public fixed byte Data[1]; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs new file mode 100644 index 0000000000..35b12088dc --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "tagSTATDATA")] + public unsafe partial struct TagSTATDATA + { + public TagSTATDATA + ( + TagFORMATETC? formatetc = null, + uint? advf = null, + IAdviseSink* pAdvSink = null, + uint? dwConnection = null + ) : this() + { + if (formatetc is not null) + { + Formatetc = formatetc.Value; + } + + if (advf is not null) + { + Advf = advf.Value; + } + + if (pAdvSink is not null) + { + PAdvSink = pAdvSink; + } + + if (dwConnection is not null) + { + DwConnection = dwConnection.Value; + } + } + + + [NativeName("Type", "FORMATETC")] + [NativeName("Type.Name", "FORMATETC")] + [NativeName("Name", "formatetc")] + public TagFORMATETC Formatetc; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "advf")] + public uint Advf; + + [NativeName("Type", "IAdviseSink *")] + [NativeName("Type.Name", "IAdviseSink *")] + [NativeName("Name", "pAdvSink")] + public IAdviseSink* PAdvSink; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "dwConnection")] + public uint DwConnection; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs new file mode 100644 index 0000000000..78b896e096 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs @@ -0,0 +1,202 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagSTGMEDIUM")] + public unsafe partial struct TagSTGMEDIUM + { + public TagSTGMEDIUM + ( + uint? tymed = null, + TagSTGMEDIUMUnion? anonymous = null, + Silk.NET.Core.Native.IUnknown* pUnkForRelease = null, + void* hBitmap = null, + void* hMetaFilePict = null, + nint* hEnhMetaFile = null, + void* hGlobal = null, + char* lpszFileName = null, + Silk.NET.Core.Win32Extras.IStream* pstm = null, + IStorage* pstg = null + ) : this() + { + if (tymed is not null) + { + Tymed = tymed.Value; + } + + if (anonymous is not null) + { + Anonymous = anonymous.Value; + } + + if (pUnkForRelease is not null) + { + PUnkForRelease = pUnkForRelease; + } + + if (hBitmap is not null) + { + HBitmap = hBitmap; + } + + if (hMetaFilePict is not null) + { + HMetaFilePict = hMetaFilePict; + } + + if (hEnhMetaFile is not null) + { + HEnhMetaFile = hEnhMetaFile; + } + + if (hGlobal is not null) + { + HGlobal = hGlobal; + } + + if (lpszFileName is not null) + { + LpszFileName = lpszFileName; + } + + if (pstm is not null) + { + Pstm = pstm; + } + + if (pstg is not null) + { + Pstg = pstg; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "tymed")] + public uint Tymed; + + [NativeName("Type", "")] + [NativeName("Type.Name", "__AnonymousRecord_objidl_L12046_C36")] + [NativeName("Name", "anonymous1")] + public TagSTGMEDIUMUnion Anonymous; + + [NativeName("Type", "IUnknown *")] + [NativeName("Type.Name", "IUnknown *")] + [NativeName("Name", "pUnkForRelease")] + public Silk.NET.Core.Native.IUnknown* PUnkForRelease; +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref void* HBitmap + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HBitmap; + } +#else + public void* HBitmap + { + get => Anonymous.HBitmap; + set => Anonymous.HBitmap = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref void* HMetaFilePict + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HMetaFilePict; + } +#else + public void* HMetaFilePict + { + get => Anonymous.HMetaFilePict; + set => Anonymous.HMetaFilePict = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref nint* HEnhMetaFile + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HEnhMetaFile; + } +#else + public nint* HEnhMetaFile + { + get => Anonymous.HEnhMetaFile; + set => Anonymous.HEnhMetaFile = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref void* HGlobal + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].HGlobal; + } +#else + public void* HGlobal + { + get => Anonymous.HGlobal; + set => Anonymous.HGlobal = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref char* LpszFileName + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].LpszFileName; + } +#else + public char* LpszFileName + { + get => Anonymous.LpszFileName; + set => Anonymous.LpszFileName = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref Silk.NET.Core.Win32Extras.IStream* Pstm + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pstm; + } +#else + public Silk.NET.Core.Win32Extras.IStream* Pstm + { + get => Anonymous.Pstm; + set => Anonymous.Pstm = value; + } +#endif + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public ref IStorage* Pstg + { + [MethodImpl((MethodImplOptions) 768)] + get => ref MemoryMarshal.CreateSpan(ref Anonymous, 1)[0].Pstg; + } +#else + public IStorage* Pstg + { + get => Anonymous.Pstg; + set => Anonymous.Pstg = value; + } +#endif + + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs new file mode 100644 index 0000000000..a582aa2b20 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs @@ -0,0 +1,113 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)] + [NativeName("Name", "__AnonymousRecord_objidl_L12046_C36")] + public unsafe partial struct TagSTGMEDIUMUnion + { + public TagSTGMEDIUMUnion + ( + void* hBitmap = null, + void* hMetaFilePict = null, + nint* hEnhMetaFile = null, + void* hGlobal = null, + char* lpszFileName = null, + Silk.NET.Core.Win32Extras.IStream* pstm = null, + IStorage* pstg = null + ) : this() + { + if (hBitmap is not null) + { + HBitmap = hBitmap; + } + + if (hMetaFilePict is not null) + { + HMetaFilePict = hMetaFilePict; + } + + if (hEnhMetaFile is not null) + { + HEnhMetaFile = hEnhMetaFile; + } + + if (hGlobal is not null) + { + HGlobal = hGlobal; + } + + if (lpszFileName is not null) + { + LpszFileName = lpszFileName; + } + + if (pstm is not null) + { + Pstm = pstm; + } + + if (pstg is not null) + { + Pstg = pstg; + } + } + + + [FieldOffset(0)] + [NativeName("Type", "HBITMAP")] + [NativeName("Type.Name", "HBITMAP")] + [NativeName("Name", "hBitmap")] + public void* HBitmap; + + [FieldOffset(0)] + [NativeName("Type", "HMETAFILEPICT")] + [NativeName("Type.Name", "HMETAFILEPICT")] + [NativeName("Name", "hMetaFilePict")] + public void* HMetaFilePict; + + [FieldOffset(0)] + [NativeName("Type", "HENHMETAFILE")] + [NativeName("Type.Name", "HENHMETAFILE")] + [NativeName("Name", "hEnhMetaFile")] + public nint* HEnhMetaFile; + + [FieldOffset(0)] + [NativeName("Type", "HGLOBAL")] + [NativeName("Type.Name", "HGLOBAL")] + [NativeName("Name", "hGlobal")] + public void* HGlobal; + + [FieldOffset(0)] + [NativeName("Type", "LPOLESTR")] + [NativeName("Type.Name", "LPOLESTR")] + [NativeName("Name", "lpszFileName")] + public char* LpszFileName; + + [FieldOffset(0)] + [NativeName("Type", "IStream *")] + [NativeName("Type.Name", "IStream *")] + [NativeName("Name", "pstm")] + public Silk.NET.Core.Win32Extras.IStream* Pstm; + + [FieldOffset(0)] + [NativeName("Type", "IStorage *")] + [NativeName("Type.Name", "IStorage *")] + [NativeName("Name", "pstg")] + public IStorage* Pstg; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs new file mode 100644 index 0000000000..e749c09b73 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs @@ -0,0 +1,73 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] + [NativeName("Name", "tagStorageLayout")] + public unsafe partial struct TagStorageLayout + { + public TagStorageLayout + ( + uint? layoutType = null, + char* pwcsElementName = null, + long? cOffset = null, + long? cBytes = null + ) : this() + { + if (layoutType is not null) + { + LayoutType = layoutType.Value; + } + + if (pwcsElementName is not null) + { + PwcsElementName = pwcsElementName; + } + + if (cOffset is not null) + { + COffset = cOffset.Value; + } + + if (cBytes is not null) + { + CBytes = cBytes.Value; + } + } + + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "LayoutType")] + public uint LayoutType; + + [NativeName("Type", "OLECHAR *")] + [NativeName("Type.Name", "OLECHAR *")] + [NativeName("Name", "pwcsElementName")] + public char* PwcsElementName; + + [NativeName("Type", "LARGE_INTEGER")] + [NativeName("Type.Name", "LARGE_INTEGER")] + [NativeName("Name", "cOffset")] + public long COffset; + + [NativeName("Type", "LARGE_INTEGER")] + [NativeName("Type.Name", "LARGE_INTEGER")] + [NativeName("Name", "cBytes")] + public long CBytes; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ThumbnailExtractorVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ThumbnailExtractorVtblExtensions.gen.cs new file mode 100644 index 0000000000..e40b144d6e --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ThumbnailExtractorVtblExtensions.gen.cs @@ -0,0 +1,574 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class ThumbnailExtractorVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStg, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLength, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeight, phOutputBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmap); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ref IStorage pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + fixed (uint* pulOutputLengthPtr = &pulOutputLength) + { + fixed (uint* pulOutputHeightPtr = &pulOutputHeight) + { + fixed (void** phOutputBitmapPtr = &phOutputBitmap) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStgPtr, ulLength, ulHeight, pulOutputLengthPtr, pulOutputHeightPtr, phOutputBitmapPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int OnFileUpdated(this ComPtr thisVtbl, IStorage* pStg) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pStg); + return ret; + } + + /// To be documented. + public static int OnFileUpdated(this ComPtr thisVtbl, ref IStorage pStg) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IStorage* pStgPtr = &pStg) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pStgPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, Span pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(pStg, ulLength, ulHeight, pulOutputLength, ref pulOutputHeight.GetPinnableReference(), phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, ref pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, Span pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(pStg, ulLength, ulHeight, pulOutputLength, ref pulOutputHeight.GetPinnableReference(), ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, pulOutputLength, ref pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, Span pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(pStg, ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, Span pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(pStg, ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, Span pulOutputLength, Span pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(pStg, ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), ref pulOutputHeight.GetPinnableReference(), phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, void** phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, ref pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, IStorage* pStg, uint ulLength, uint ulHeight, Span pulOutputLength, Span pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(pStg, ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), ref pulOutputHeight.GetPinnableReference(), ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, ComPtr pStg, uint ulLength, uint ulHeight, ref uint pulOutputLength, ref uint pulOutputHeight, ref void* phOutputBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->ExtractThumbnail((IStorage*) pStg.Handle, ulLength, ulHeight, ref pulOutputLength, ref pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, pulOutputLength, pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, pulOutputLength, pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, Span pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, pulOutputLength, ref pulOutputHeight.GetPinnableReference(), phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, uint* pulOutputLength, Span pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, pulOutputLength, ref pulOutputHeight.GetPinnableReference(), ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, Span pulOutputLength, uint* pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), pulOutputHeight, phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, Span pulOutputLength, uint* pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), pulOutputHeight, ref phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, Span pulOutputLength, Span pulOutputHeight, void** phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), ref pulOutputHeight.GetPinnableReference(), phOutputBitmap); + } + + /// To be documented. + public static unsafe int ExtractThumbnail(this ComPtr thisVtbl, Span pStg, uint ulLength, uint ulHeight, Span pulOutputLength, Span pulOutputHeight, ref void* phOutputBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->ExtractThumbnail(ref pStg.GetPinnableReference(), ulLength, ulHeight, ref pulOutputLength.GetPinnableReference(), ref pulOutputHeight.GetPinnableReference(), ref phOutputBitmap); + } + + /// To be documented. + public static int OnFileUpdated(this ComPtr thisVtbl, ComPtr pStg) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->OnFileUpdated((IStorage*) pStg.Handle); + } + + /// To be documented. + public static int OnFileUpdated(this ComPtr thisVtbl, Span pStg) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->OnFileUpdated(ref pStg.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TimeAndNoticeControlVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/TimeAndNoticeControlVtblExtensions.gen.cs new file mode 100644 index 0000000000..0a178c0ef3 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/TimeAndNoticeControlVtblExtensions.gen.cs @@ -0,0 +1,130 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class TimeAndNoticeControlVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int SuppressChanges(this ComPtr thisVtbl, uint res1, uint res2) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, res1, res2); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/UrlMonVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/UrlMonVtblExtensions.gen.cs new file mode 100644 index 0000000000..8ac3075e4f --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/UrlMonVtblExtensions.gen.cs @@ -0,0 +1,6645 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras; + +public unsafe static class UrlMonVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsid, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPE, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + fixed (char* pszTYPEPtr = &pszTYPE) + { + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + fixed (char* pszExtPtr = &pszExt) + { + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + } + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + fixed (char* pszCodeBasePtr = &pszCodeBase) + { + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + } + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riid, flags); + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbc, dwClassContext, riidPtr, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riid, flags); + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ref IBindCtx pbc, uint dwClassContext, ref Guid riid, uint flags) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* rclsidPtr = &rclsid) + { + var pszTYPEPtr = (byte*) SilkMarshal.StringToPtr(pszTYPE, NativeStringEncoding.LPWStr); + var pszExtPtr = (byte*) SilkMarshal.StringToPtr(pszExt, NativeStringEncoding.LPWStr); + var pszCodeBasePtr = (byte*) SilkMarshal.StringToPtr(pszCodeBase, NativeStringEncoding.LPWStr); + fixed (IBindCtx* pbcPtr = &pbc) + { + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, rclsidPtr, pszTYPEPtr, pszExtPtr, dwFileVersionMS, dwFileVersionLS, pszCodeBasePtr, pbcPtr, dwClassContext, riidPtr, flags); + } + } + SilkMarshal.Free((nint)pszCodeBasePtr); + SilkMarshal.Free((nint)pszExtPtr); + SilkMarshal.Free((nint)pszTYPEPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Guid* rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, in pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), in pszTYPE.GetPinnableReference(), pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, in pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, in pszExt.GetPinnableReference(), dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, in pszCodeBase.GetPinnableReference(), ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, Guid* riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, IBindCtx* pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, pbc, dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, ref Guid rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, ComPtr pbc, uint dwClassContext, ref Guid riid, uint flags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AsyncGetClassBits(ref rclsid, pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, (IBindCtx*) pbc.Handle, dwClassContext, ref riid, flags); + } + + /// To be documented. + public static unsafe int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Guid* riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, riid, flags); + } + + /// To be documented. + public static int AsyncGetClassBits(this ComPtr thisVtbl, Span rclsid, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszTYPE, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszExt, uint dwFileVersionMS, uint dwFileVersionLS, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pszCodeBase, Span pbc, uint dwClassContext, Span riid, uint flags) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AsyncGetClassBits(ref rclsid.GetPinnableReference(), pszTYPE, pszExt, dwFileVersionMS, dwFileVersionLS, pszCodeBase, ref pbc.GetPinnableReference(), dwClassContext, ref riid.GetPinnableReference(), flags); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/UserFLAGSTGMEDIUM.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/UserFLAGSTGMEDIUM.gen.cs new file mode 100644 index 0000000000..05ae83596b --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/UserFLAGSTGMEDIUM.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "_userFLAG_STGMEDIUM")] + public unsafe partial struct UserFLAGSTGMEDIUM + { + public UserFLAGSTGMEDIUM + ( + int? contextFlags = null, + int? fPassOwnership = null, + UserSTGMEDIUM? stgmed = null + ) : this() + { + if (contextFlags is not null) + { + ContextFlags = contextFlags.Value; + } + + if (fPassOwnership is not null) + { + FPassOwnership = fPassOwnership.Value; + } + + if (stgmed is not null) + { + Stgmed = stgmed.Value; + } + } + + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "ContextFlags")] + public int ContextFlags; + + [NativeName("Type", "LONG")] + [NativeName("Type.Name", "LONG")] + [NativeName("Name", "fPassOwnership")] + public int FPassOwnership; + + [NativeName("Type", "userSTGMEDIUM")] + [NativeName("Type.Name", "userSTGMEDIUM")] + [NativeName("Name", "Stgmed")] + public UserSTGMEDIUM Stgmed; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/UserSTGMEDIUM.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/UserSTGMEDIUM.gen.cs new file mode 100644 index 0000000000..5f9308d545 --- /dev/null +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/UserSTGMEDIUM.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.Core.Win32Extras +{ + [NativeName("Name", "_userSTGMEDIUM")] + public unsafe partial struct UserSTGMEDIUM + { + public UserSTGMEDIUM + ( + Silk.NET.Core.Native.IUnknown* pUnkForRelease = null + ) : this() + { + if (pUnkForRelease is not null) + { + PUnkForRelease = pUnkForRelease; + } + } + + + [NativeName("Type", "IUnknown *")] + [NativeName("Type.Name", "IUnknown *")] + [NativeName("Name", "pUnkForRelease")] + public Silk.NET.Core.Native.IUnknown* PUnkForRelease; + } +} diff --git a/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs index 473c761bbb..401165c7e6 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs @@ -18351,4656 +18351,25710 @@ public unsafe partial class Windows : NativeAPI public partial int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] + public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(IBindCtx* This, TagBINDOPTS2* pbindopts); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] + public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS2 pbindopts); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] + public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS2* pbindopts); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] + public partial int IBindCtxRemoteSetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 541, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventRegister")] - public partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 555, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventUnregister")] - public partial uint EventUnregister(ulong RegHandle); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 568, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventSetInformation")] - public unsafe partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, void* EventInformation, uint InformationLength); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 568, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventSetInformation")] - public partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, ref T0 EventInformation, uint InformationLength) where T0 : unmanaged; + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 611, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventEnabled")] - public unsafe partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 611, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventEnabled")] - public partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 652, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventProviderEnabled")] - public partial byte EventProviderEnabled(ulong RegHandle, byte Level, ulong Keyword); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 677, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWrite")] - public partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Stub")] + public partial void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] + public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(IBindCtx* This, TagBINDOPTS2* pbindopts); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] + public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS2 pbindopts); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] + public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS2* pbindopts); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] + public partial int IBindCtxRemoteGetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 702, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteTransfer")] - public partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public unsafe partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Stub")] + public partial void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(IEnumMoniker* This, uint celt, IMoniker** rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(IEnumMoniker* This, uint celt, IMoniker** rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(IEnumMoniker* This, uint celt, ref IMoniker* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(IEnumMoniker* This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, IMoniker** rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, IMoniker** rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref IMoniker* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Proxy")] + public unsafe partial int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 736, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteEx")] - public partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 754, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteString")] - public unsafe partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* String); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 754, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteString")] - public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char String); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 754, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventWriteString")] - public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string String); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 781, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventActivityIdControl")] - public unsafe partial uint EventActivityIdControl(uint ControlCode, Guid* ActivityId); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 781, Column 1 in evntprov.h")] - [NativeApi(EntryPoint = "EventActivityIdControl")] - public partial uint EventActivityIdControl(uint ControlCode, ref Guid ActivityId); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public unsafe partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_RemoteNext_Stub")] + public partial void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9611, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Proxy")] + public unsafe partial int IRunnableObjectRemoteIsRunningProxy(IRunnableObject* This); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9611, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Proxy")] + public partial int IRunnableObjectRemoteIsRunningProxy(ref IRunnableObject This); /// To be documented. - [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceW")] - public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StartTraceA")] - public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public unsafe partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_RemoteIsRunning_Stub")] + public partial void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceW")] - public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "StopTraceA")] - public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceW")] - public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceA")] - public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceW")] - public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Proxy")] + public unsafe partial int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); /// To be documented. - [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UpdateTraceA")] - public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceW")] - public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "FlushTraceA")] - public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public unsafe partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToObject_Stub")] + public partial void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceW")] - public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ControlTraceA")] - public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesW")] - public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryAllTracesA")] - public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTrace")] - public unsafe partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, ulong TraceHandle); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTrace")] - public partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, ulong TraceHandle); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx")] - public partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnableTraceEx2")] - public partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Proxy")] + public unsafe partial int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] - public partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceSetInformation")] - public unsafe partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength); + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceSetInformation")] - public partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, uint* ReturnLength); + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, ref uint ReturnLength); + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceQueryInformation")] - public partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public unsafe partial uint CreateTraceInstanceId(void* RegHandle, EventInstanceInfo* InstInfo); + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public unsafe partial uint CreateTraceInstanceId(void* RegHandle, ref EventInstanceInfo InstInfo); + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public unsafe partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public unsafe partial uint CreateTraceInstanceId(ref T0 RegHandle, EventInstanceInfo* InstInfo) where T0 : unmanaged; + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_RemoteBindToStorage_Stub")] + public partial void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CreateTraceInstanceId")] - public partial uint CreateTraceInstanceId(ref T0 RegHandle, ref EventInstanceInfo InstInfo) where T0 : unmanaged; + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(IEnumSTATSTG* This, uint celt, STATSTG* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEvent")] - public unsafe partial uint TraceEvent(ulong TraceHandle, EventTraceHeader* EventTrace); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(IEnumSTATSTG* This, uint celt, STATSTG* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEvent")] - public partial uint TraceEvent(ulong TraceHandle, ref EventTraceHeader EventTrace); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(IEnumSTATSTG* This, uint celt, ref STATSTG rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(IEnumSTATSTG* This, uint celt, ref STATSTG rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(ref IEnumSTATSTG This, uint celt, STATSTG* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(ref IEnumSTATSTG This, uint celt, STATSTG* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATSTGRemoteNextProxy(ref IEnumSTATSTG This, uint celt, ref STATSTG rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Proxy")] + public partial int IEnumSTATSTGRemoteNextProxy(ref IEnumSTATSTG This, uint celt, ref STATSTG rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceEventInstance")] - public partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public unsafe partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_RemoteNext_Stub")] + public partial void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Proxy")] + public unsafe partial int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public unsafe partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteOpenStream_Stub")] + public partial void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Proxy")] + public unsafe partial int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public unsafe partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteCopyTo_Stub")] + public partial void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(IStorage* This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, IEnumSTATSTG** ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(IStorage* This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(IStorage* This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, IEnumSTATSTG** ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(IStorage* This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(IStorage* This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, IEnumSTATSTG** ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(IStorage* This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, IEnumSTATSTG** ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, IEnumSTATSTG** ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, IEnumSTATSTG** ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Proxy")] + public unsafe partial int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public unsafe partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_RemoteEnumElements_Stub")] + public partial void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ILockBytes* This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ILockBytes* This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ILockBytes* This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ILockBytes* This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ILockBytes* This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ILockBytes* This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ref ILockBytes This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ref ILockBytes This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ref ILockBytes This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public partial int ILockBytesRemoteReadAtProxy(ref ILockBytes This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public unsafe partial int ILockBytesRemoteReadAtProxy(ref ILockBytes This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Proxy")] + public partial int ILockBytesRemoteReadAtProxy(ref ILockBytes This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsW")] - public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public unsafe partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteReadAt_Stub")] + public partial void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public partial int ILockBytesRemoteWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public unsafe partial int ILockBytesRemoteWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Proxy")] + public partial int ILockBytesRemoteWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public unsafe partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_RemoteWriteAt_Stub")] + public partial void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] + public partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public unsafe partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Stub")] + public partial void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] + public partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public unsafe partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Stub")] + public partial void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] + public partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Stub")] + public partial void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12255, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnViewChangeProxy(IAdviseSink* This, uint dwAspect, int lindex); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12255, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Proxy")] + public partial int IAdviseSinkRemoteOnViewChangeProxy(ref IAdviseSink This, uint dwAspect, int lindex); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public unsafe partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnViewChange_Stub")] + public partial void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnRenameProxy(IAdviseSink* This, IMoniker* pmk); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnRenameProxy(IAdviseSink* This, ref IMoniker pmk); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnRenameProxy(ref IAdviseSink This, IMoniker* pmk); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Proxy")] + public partial int IAdviseSinkRemoteOnRenameProxy(ref IAdviseSink This, ref IMoniker pmk); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RegisterTraceGuidsA")] - public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public unsafe partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnRename_Stub")] + public partial void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "EnumerateTraceGuids")] - public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + [NativeName("Src", "Line 12280, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnSaveProxy(IAdviseSink* This); /// To be documented. - [NativeName("Src", "Line 2573, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "UnregisterTraceGuids")] - public partial uint UnregisterTraceGuids(ulong RegistrationHandle); + [NativeName("Src", "Line 12280, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Proxy")] + public partial int IAdviseSinkRemoteOnSaveProxy(ref IAdviseSink This); /// To be documented. - [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceLoggerHandle")] - public unsafe partial ulong GetTraceLoggerHandle(void* Buffer); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceLoggerHandle")] - public partial ulong GetTraceLoggerHandle(ref T0 Buffer) where T0 : unmanaged; + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2587, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceEnableLevel")] - public partial byte GetTraceEnableLevel(ulong TraceHandle); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2594, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "GetTraceEnableFlags")] - public partial uint GetTraceEnableFlags(ulong TraceHandle); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceW")] - public unsafe partial ulong OpenTraceW(EventTraceLogfilew* Logfile); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceW")] - public partial ulong OpenTraceW(ref EventTraceLogfilew Logfile); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTrace")] - public partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2638, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "CloseTrace")] - public partial uint CloseTrace(ulong TraceHandle); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public unsafe partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnSave_Stub")] + public partial void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + [NativeName("Src", "Line 12291, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Proxy")] + public unsafe partial int IAdviseSinkRemoteOnCloseProxy(IAdviseSink* This); /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + [NativeName("Src", "Line 12291, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Proxy")] + public partial int IAdviseSinkRemoteOnCloseProxy(ref IAdviseSink This); /// To be documented. - [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] - public partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] - public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public unsafe partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_RemoteOnClose_Stub")] + public partial void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] + public partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] - public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Stub")] + public partial void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12494, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(AsyncIAdviseSink* This); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12494, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Proxy")] + public partial int AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(ref AsyncIAdviseSink This); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceFromFile")] - public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] - public unsafe partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] - public partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwBufferHeader Buffer); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] - public unsafe partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] - public partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwBufferHeader Buffer); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] - public unsafe partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer, uint BufferSize); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] - public partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwBufferHeader Buffer, uint BufferSize); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnDataChange_Stub")] + public partial void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 12505, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(AsyncIAdviseSink* This, uint dwAspect, int lindex); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 12505, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Proxy")] + public partial int AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(ref AsyncIAdviseSink This, uint dwAspect, int lindex); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] - public partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceA")] - public unsafe partial ulong OpenTraceA(EventTraceLogfilea* Logfile); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "OpenTraceA")] - public partial ulong OpenTraceA(ref EventTraceLogfilea Logfile); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "SetTraceCallback")] - public unsafe partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid, PfnPeventCallback EventCallback); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "SetTraceCallback")] - public partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pGuid, PfnPeventCallback EventCallback); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RemoveTraceCallback")] - public unsafe partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "RemoveTraceCallback")] - public partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pGuid); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessage")] - public unsafe partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessage")] - public partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, byte* MessageArgList); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, ref byte MessageArgList); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber, byte* MessageArgList); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber, ref byte MessageArgList); + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnViewChange_Stub")] + public partial void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] - [NativeApi(EntryPoint = "TraceMessageVa")] - public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + [NativeName("Src", "Line 12518, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Proxy")] + public unsafe partial int AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(AsyncIAdviseSink* This); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) - { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; - } + [NativeName("Src", "Line 12518, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Proxy")] + public partial int AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(ref AsyncIAdviseSink This); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) - { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; - } + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) - { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; - } + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) - { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; - } + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) - { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; - } + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) - { - // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; - } + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnViewChange_Stub")] + public partial void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnRenameProxy(AsyncIAdviseSink* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnRenameProxy(AsyncIAdviseSink* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref AsyncIAdviseSink This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Proxy")] + public partial int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref AsyncIAdviseSink This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnRename_Stub")] + public partial void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12541, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Proxy")] + public unsafe partial int AsyncIAdviseSinkFinishRemoteOnRenameProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 12541, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Proxy")] + public partial int AsyncIAdviseSinkFinishRemoteOnRenameProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnRename_Stub")] + public partial void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12552, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnSaveProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 12552, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Proxy")] + public partial int AsyncIAdviseSinkBeginRemoteOnSaveProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnSave_Stub")] + public partial void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12563, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Proxy")] + public unsafe partial int AsyncIAdviseSinkFinishRemoteOnSaveProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 12563, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Proxy")] + public partial int AsyncIAdviseSinkFinishRemoteOnSaveProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnSave_Stub")] + public partial void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12574, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Proxy")] + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnCloseProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 12574, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Proxy")] + public partial int AsyncIAdviseSinkBeginRemoteOnCloseProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnClose_Stub")] + public partial void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12585, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Proxy")] + public unsafe partial int AsyncIAdviseSinkFinishRemoteOnCloseProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 12585, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Proxy")] + public partial int AsyncIAdviseSinkFinishRemoteOnCloseProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public unsafe partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_RemoteOnClose_Stub")] + public partial void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int IAdviseSink2RemoteOnLinkSrcChangeProxy(IAdviseSink2* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int IAdviseSink2RemoteOnLinkSrcChangeProxy(IAdviseSink2* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int IAdviseSink2RemoteOnLinkSrcChangeProxy(ref IAdviseSink2 This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Proxy")] + public partial int IAdviseSink2RemoteOnLinkSrcChangeProxy(ref IAdviseSink2 This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_RemoteOnLinkSrcChange_Stub")] + public partial void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(AsyncIAdviseSink2* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(AsyncIAdviseSink2* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Proxy")] + public partial int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_RemoteOnLinkSrcChange_Stub")] + public partial void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12938, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Proxy")] + public unsafe partial int AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(AsyncIAdviseSink2* This); + + /// To be documented. + [NativeName("Src", "Line 12938, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Proxy")] + public partial int AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public unsafe partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_RemoteOnLinkSrcChange_Stub")] + public partial void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] + public partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public unsafe partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Stub")] + public partial void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] + public partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public unsafe partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Stub")] + public partial void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] + public partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public unsafe partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Stub")] + public partial void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public partial int IFillLockBytesRemoteFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Proxy")] + public partial int IFillLockBytesRemoteFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAppend_Stub")] + public partial void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public partial int IFillLockBytesRemoteFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public unsafe partial int IFillLockBytesRemoteFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Proxy")] + public partial int IFillLockBytesRemoteFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(IRpcStubBuffer* This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, IRpcChannelBuffer* _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public unsafe partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_RemoteFillAt_Stub")] + public partial void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] + public unsafe partial uint ASYNCSTGMEDIUMUserSize(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] + public unsafe partial uint ASYNCSTGMEDIUMUserSize(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] + public unsafe partial uint ASYNCSTGMEDIUMUserSize(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] + public partial uint ASYNCSTGMEDIUMUserSize(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] + public partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] + public partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] + public unsafe partial void ASYNCSTGMEDIUMUserFree(uint* arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] + public unsafe partial void ASYNCSTGMEDIUMUserFree(uint* arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] + public unsafe partial void ASYNCSTGMEDIUMUserFree(ref uint arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] + public partial void ASYNCSTGMEDIUMUserFree(ref uint arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize")] + public unsafe partial uint CLIPFORMATUserSize(uint* arg0, uint arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize")] + public unsafe partial uint CLIPFORMATUserSize(uint* arg0, uint arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize")] + public unsafe partial uint CLIPFORMATUserSize(ref uint arg0, uint arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize")] + public partial uint CLIPFORMATUserSize(ref uint arg0, uint arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public partial string CLIPFORMATUserMarshalS(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal")] + public partial string CLIPFORMATUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public partial string CLIPFORMATUserUnmarshalS(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal")] + public partial string CLIPFORMATUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree")] + public unsafe partial void CLIPFORMATUserFree(uint* arg0, ushort* arg1); + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree")] + public unsafe partial void CLIPFORMATUserFree(uint* arg0, ref ushort arg1); + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree")] + public unsafe partial void CLIPFORMATUserFree(ref uint arg0, ushort* arg1); + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree")] + public partial void CLIPFORMATUserFree(ref uint arg0, ref ushort arg1); + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize")] + public unsafe partial uint FLAGSTGMEDIUMUserSize(uint* arg0, uint arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize")] + public unsafe partial uint FLAGSTGMEDIUMUserSize(uint* arg0, uint arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize")] + public unsafe partial uint FLAGSTGMEDIUMUserSize(ref uint arg0, uint arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize")] + public partial uint FLAGSTGMEDIUMUserSize(ref uint arg0, uint arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public partial string FLAGSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial string FLAGSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal")] + public partial string FLAGSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public partial string FLAGSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal")] + public partial string FLAGSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree")] + public unsafe partial void FLAGSTGMEDIUMUserFree(uint* arg0, FlagStgmedium* arg1); + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree")] + public unsafe partial void FLAGSTGMEDIUMUserFree(uint* arg0, ref FlagStgmedium arg1); + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree")] + public unsafe partial void FLAGSTGMEDIUMUserFree(ref uint arg0, FlagStgmedium* arg1); + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree")] + public partial void FLAGSTGMEDIUMUserFree(ref uint arg0, ref FlagStgmedium arg1); + + /// To be documented. + [NativeName("Src", "Line 15478, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize")] + public unsafe partial uint HBITMAPUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15478, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize")] + public unsafe partial uint HBITMAPUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15478, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize")] + public unsafe partial uint HBITMAPUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15478, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize")] + public unsafe partial uint HBITMAPUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal")] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal")] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15481, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree")] + public unsafe partial void HBITMAPUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15481, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree")] + public unsafe partial void HBITMAPUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15481, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree")] + public unsafe partial void HBITMAPUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15481, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree")] + public unsafe partial void HBITMAPUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize")] + public unsafe partial uint HDCUserSize(uint* arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize")] + public unsafe partial uint HDCUserSize(uint* arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize")] + public unsafe partial uint HDCUserSize(ref uint arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize")] + public partial uint HDCUserSize(ref uint arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public partial string HDCUserMarshalS(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial string HDCUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public unsafe partial byte* HDCUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal")] + public partial string HDCUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public partial string HDCUserUnmarshalS(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial string HDCUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public unsafe partial byte* HDCUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal")] + public partial string HDCUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree")] + public unsafe partial void HDCUserFree(uint* arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree")] + public unsafe partial void HDCUserFree(uint* arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree")] + public unsafe partial void HDCUserFree(ref uint arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree")] + public partial void HDCUserFree(ref uint arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 15488, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize")] + public unsafe partial uint HICONUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15488, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize")] + public unsafe partial uint HICONUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15488, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize")] + public unsafe partial uint HICONUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15488, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize")] + public unsafe partial uint HICONUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal")] + public unsafe partial string HICONUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal")] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15491, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree")] + public unsafe partial void HICONUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15491, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree")] + public unsafe partial void HICONUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15491, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree")] + public unsafe partial void HICONUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15491, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree")] + public unsafe partial void HICONUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15493, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize")] + public unsafe partial uint SNBUserSize(uint* arg0, uint arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15493, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize")] + public unsafe partial uint SNBUserSize(uint* arg0, uint arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15493, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize")] + public unsafe partial uint SNBUserSize(ref uint arg0, uint arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15493, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize")] + public unsafe partial uint SNBUserSize(ref uint arg0, uint arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial byte* SNBUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal")] + public unsafe partial string SNBUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial byte* SNBUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal")] + public unsafe partial string SNBUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15496, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree")] + public unsafe partial void SNBUserFree(uint* arg0, char*** arg1); + + /// To be documented. + [NativeName("Src", "Line 15496, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree")] + public unsafe partial void SNBUserFree(uint* arg0, ref char** arg1); + + /// To be documented. + [NativeName("Src", "Line 15496, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree")] + public unsafe partial void SNBUserFree(ref uint arg0, char*** arg1); + + /// To be documented. + [NativeName("Src", "Line 15496, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree")] + public unsafe partial void SNBUserFree(ref uint arg0, ref char** arg1); + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] + public unsafe partial uint STGMEDIUMUserSize(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] + public unsafe partial uint STGMEDIUMUserSize(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] + public unsafe partial uint STGMEDIUMUserSize(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] + public partial uint STGMEDIUMUserSize(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public partial string STGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] + public partial string STGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public partial string STGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] + public partial string STGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] + public unsafe partial void STGMEDIUMUserFree(uint* arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] + public unsafe partial void STGMEDIUMUserFree(uint* arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] + public unsafe partial void STGMEDIUMUserFree(ref uint arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] + public partial void STGMEDIUMUserFree(ref uint arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] + public unsafe partial uint ASYNCSTGMEDIUMUserSize64(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] + public unsafe partial uint ASYNCSTGMEDIUMUserSize64(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] + public unsafe partial uint ASYNCSTGMEDIUMUserSize64(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] + public partial uint ASYNCSTGMEDIUMUserSize64(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] + public partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] + public partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] + public unsafe partial void ASYNCSTGMEDIUMUserFree64(uint* arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] + public unsafe partial void ASYNCSTGMEDIUMUserFree64(uint* arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] + public unsafe partial void ASYNCSTGMEDIUMUserFree64(ref uint arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] + public partial void ASYNCSTGMEDIUMUserFree64(ref uint arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize64")] + public unsafe partial uint CLIPFORMATUserSize64(uint* arg0, uint arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize64")] + public unsafe partial uint CLIPFORMATUserSize64(uint* arg0, uint arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize64")] + public unsafe partial uint CLIPFORMATUserSize64(ref uint arg0, uint arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize64")] + public partial uint CLIPFORMATUserSize64(ref uint arg0, uint arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public partial string CLIPFORMATUserMarshal64S(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial string CLIPFORMATUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public unsafe partial byte* CLIPFORMATUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal64")] + public partial string CLIPFORMATUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public partial string CLIPFORMATUserUnmarshal64S(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial string CLIPFORMATUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public unsafe partial byte* CLIPFORMATUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal64")] + public partial string CLIPFORMATUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree64")] + public unsafe partial void CLIPFORMATUserFree64(uint* arg0, ushort* arg1); + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree64")] + public unsafe partial void CLIPFORMATUserFree64(uint* arg0, ref ushort arg1); + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree64")] + public unsafe partial void CLIPFORMATUserFree64(ref uint arg0, ushort* arg1); + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree64")] + public partial void CLIPFORMATUserFree64(ref uint arg0, ref ushort arg1); + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize64")] + public unsafe partial uint FLAGSTGMEDIUMUserSize64(uint* arg0, uint arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize64")] + public unsafe partial uint FLAGSTGMEDIUMUserSize64(uint* arg0, uint arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize64")] + public unsafe partial uint FLAGSTGMEDIUMUserSize64(ref uint arg0, uint arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserSize64")] + public partial uint FLAGSTGMEDIUMUserSize64(ref uint arg0, uint arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public partial string FLAGSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserMarshal64")] + public partial string FLAGSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public partial string FLAGSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial string FLAGSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* FLAGSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserUnmarshal64")] + public partial string FLAGSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref FlagStgmedium arg2); + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree64")] + public unsafe partial void FLAGSTGMEDIUMUserFree64(uint* arg0, FlagStgmedium* arg1); + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree64")] + public unsafe partial void FLAGSTGMEDIUMUserFree64(uint* arg0, ref FlagStgmedium arg1); + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree64")] + public unsafe partial void FLAGSTGMEDIUMUserFree64(ref uint arg0, FlagStgmedium* arg1); + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "FLAG_STGMEDIUM_UserFree64")] + public partial void FLAGSTGMEDIUMUserFree64(ref uint arg0, ref FlagStgmedium arg1); + + /// To be documented. + [NativeName("Src", "Line 15518, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize64")] + public unsafe partial uint HBITMAPUserSize64(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15518, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize64")] + public unsafe partial uint HBITMAPUserSize64(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15518, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize64")] + public unsafe partial uint HBITMAPUserSize64(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15518, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize64")] + public unsafe partial uint HBITMAPUserSize64(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial byte* HBITMAPUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal64")] + public unsafe partial string HBITMAPUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial byte* HBITMAPUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal64")] + public unsafe partial string HBITMAPUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15521, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree64")] + public unsafe partial void HBITMAPUserFree64(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15521, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree64")] + public unsafe partial void HBITMAPUserFree64(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15521, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree64")] + public unsafe partial void HBITMAPUserFree64(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15521, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree64")] + public unsafe partial void HBITMAPUserFree64(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize64")] + public unsafe partial uint HDCUserSize64(uint* arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize64")] + public unsafe partial uint HDCUserSize64(uint* arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize64")] + public unsafe partial uint HDCUserSize64(ref uint arg0, uint arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserSize64")] + public partial uint HDCUserSize64(ref uint arg0, uint arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public partial string HDCUserMarshal64S(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial string HDCUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public unsafe partial byte* HDCUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserMarshal64")] + public partial string HDCUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(uint* arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(uint* arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(uint* arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(uint* arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(ref uint arg0, byte* arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(ref uint arg0, byte* arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(ref uint arg0, ref byte arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public partial string HDCUserUnmarshal64S(ref uint arg0, ref byte arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial string HDCUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public unsafe partial byte* HDCUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HDC_UserUnmarshal64")] + public partial string HDCUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref nint arg2); + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree64")] + public unsafe partial void HDCUserFree64(uint* arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree64")] + public unsafe partial void HDCUserFree64(uint* arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree64")] + public unsafe partial void HDCUserFree64(ref uint arg0, nint* arg1); + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HDC_UserFree64")] + public partial void HDCUserFree64(ref uint arg0, ref nint arg1); + + /// To be documented. + [NativeName("Src", "Line 15528, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize64")] + public unsafe partial uint HICONUserSize64(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15528, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize64")] + public unsafe partial uint HICONUserSize64(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15528, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize64")] + public unsafe partial uint HICONUserSize64(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15528, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserSize64")] + public unsafe partial uint HICONUserSize64(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial byte* HICONUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal64")] + public unsafe partial string HICONUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial byte* HICONUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal64")] + public unsafe partial string HICONUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 15531, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree64")] + public unsafe partial void HICONUserFree64(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15531, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree64")] + public unsafe partial void HICONUserFree64(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15531, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree64")] + public unsafe partial void HICONUserFree64(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 15531, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "HICON_UserFree64")] + public unsafe partial void HICONUserFree64(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 15533, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize64")] + public unsafe partial uint SNBUserSize64(uint* arg0, uint arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15533, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize64")] + public unsafe partial uint SNBUserSize64(uint* arg0, uint arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15533, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize64")] + public unsafe partial uint SNBUserSize64(ref uint arg0, uint arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15533, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserSize64")] + public unsafe partial uint SNBUserSize64(ref uint arg0, uint arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial byte* SNBUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserMarshal64")] + public unsafe partial string SNBUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(uint* arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(uint* arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(uint* arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(uint* arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(ref uint arg0, byte* arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(ref uint arg0, byte* arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(ref uint arg0, ref byte arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(ref uint arg0, ref byte arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial byte* SNBUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "SNB_UserUnmarshal64")] + public unsafe partial string SNBUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2); + + /// To be documented. + [NativeName("Src", "Line 15536, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree64")] + public unsafe partial void SNBUserFree64(uint* arg0, char*** arg1); + + /// To be documented. + [NativeName("Src", "Line 15536, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree64")] + public unsafe partial void SNBUserFree64(uint* arg0, ref char** arg1); + + /// To be documented. + [NativeName("Src", "Line 15536, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree64")] + public unsafe partial void SNBUserFree64(ref uint arg0, char*** arg1); + + /// To be documented. + [NativeName("Src", "Line 15536, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "SNB_UserFree64")] + public unsafe partial void SNBUserFree64(ref uint arg0, ref char** arg1); + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] + public unsafe partial uint STGMEDIUMUserSize64(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] + public unsafe partial uint STGMEDIUMUserSize64(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] + public unsafe partial uint STGMEDIUMUserSize64(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] + public partial uint STGMEDIUMUserSize64(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public partial string STGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] + public partial string STGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] + public partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] + public unsafe partial void STGMEDIUMUserFree64(uint* arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] + public unsafe partial void STGMEDIUMUserFree64(uint* arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] + public unsafe partial void STGMEDIUMUserFree64(ref uint arg0, TagSTGMEDIUM* arg1); + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] + public partial void STGMEDIUMUserFree64(ref uint arg0, ref TagSTGMEDIUM arg1); + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] + public unsafe partial int IBindCtxSetBindOptionsProxy(IBindCtx* This, TagBINDOPTS* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] + public unsafe partial int IBindCtxSetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] + public unsafe partial int IBindCtxSetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] + public partial int IBindCtxSetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] + public unsafe partial int IBindCtxSetBindOptionsStub(IBindCtx* This, TagBINDOPTS2* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] + public unsafe partial int IBindCtxSetBindOptionsStub(IBindCtx* This, ref TagBINDOPTS2 pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] + public unsafe partial int IBindCtxSetBindOptionsStub(ref IBindCtx This, TagBINDOPTS2* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] + public partial int IBindCtxSetBindOptionsStub(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] + public unsafe partial int IBindCtxGetBindOptionsProxy(IBindCtx* This, TagBINDOPTS* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] + public unsafe partial int IBindCtxGetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] + public unsafe partial int IBindCtxGetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] + public partial int IBindCtxGetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] + public unsafe partial int IBindCtxGetBindOptionsStub(IBindCtx* This, TagBINDOPTS2* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] + public unsafe partial int IBindCtxGetBindOptionsStub(IBindCtx* This, ref TagBINDOPTS2 pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] + public unsafe partial int IBindCtxGetBindOptionsStub(ref IBindCtx This, TagBINDOPTS2* pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] + public partial int IBindCtxGetBindOptionsStub(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(IEnumMoniker* This, uint celt, IMoniker** rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(IEnumMoniker* This, uint celt, IMoniker** rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(IEnumMoniker* This, uint celt, ref IMoniker* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(IEnumMoniker* This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, IMoniker** rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, IMoniker** rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref IMoniker* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Proxy")] + public unsafe partial int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(IEnumMoniker* This, uint celt, IMoniker** rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(IEnumMoniker* This, uint celt, IMoniker** rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(IEnumMoniker* This, uint celt, ref IMoniker* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(IEnumMoniker* This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, IMoniker** rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, IMoniker** rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref IMoniker* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumMoniker_Next_Stub")] + public unsafe partial int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15673, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_IsRunning_Proxy")] + public unsafe partial Silk.NET.Core.Bool32 IRunnableObjectIsRunningProxy(IRunnableObject* This); + + /// To be documented. + [NativeName("Src", "Line 15673, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_IsRunning_Proxy")] + public partial Silk.NET.Core.Bool32 IRunnableObjectIsRunningProxy(ref IRunnableObject This); + + /// To be documented. + [NativeName("Src", "Line 15677, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_IsRunning_Stub")] + public unsafe partial int IRunnableObjectIsRunningStub(IRunnableObject* This); + + /// To be documented. + [NativeName("Src", "Line 15677, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IRunnableObject_IsRunning_Stub")] + public partial int IRunnableObjectIsRunningStub(ref IRunnableObject This); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Proxy")] + public unsafe partial int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, Silk.NET.Core.Native.IUnknown** ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToObject_Stub")] + public unsafe partial int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Proxy")] + public unsafe partial int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(IMoniker* This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, IBindCtx* pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, IMoniker* pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, Silk.NET.Core.Native.IUnknown** ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IMoniker_BindToStorage_Stub")] + public unsafe partial int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(IEnumSTATSTG* This, uint celt, STATSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(IEnumSTATSTG* This, uint celt, STATSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(IEnumSTATSTG* This, uint celt, ref STATSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(IEnumSTATSTG* This, uint celt, ref STATSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(ref IEnumSTATSTG This, uint celt, STATSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(ref IEnumSTATSTG This, uint celt, STATSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public unsafe partial int IEnumSTATSTGNextProxy(ref IEnumSTATSTG This, uint celt, ref STATSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Proxy")] + public partial int IEnumSTATSTGNextProxy(ref IEnumSTATSTG This, uint celt, ref STATSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(IEnumSTATSTG* This, uint celt, STATSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(IEnumSTATSTG* This, uint celt, STATSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(IEnumSTATSTG* This, uint celt, ref STATSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(IEnumSTATSTG* This, uint celt, ref STATSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(ref IEnumSTATSTG This, uint celt, STATSTG* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(ref IEnumSTATSTG This, uint celt, STATSTG* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public unsafe partial int IEnumSTATSTGNextStub(ref IEnumSTATSTG This, uint celt, ref STATSTG rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATSTG_Next_Stub")] + public partial int IEnumSTATSTGNextStub(ref IEnumSTATSTG This, uint celt, ref STATSTG rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Proxy")] + public unsafe partial int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm); + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_OpenStream_Stub")] + public unsafe partial int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Proxy")] + public unsafe partial int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, IStorage* pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_CopyTo_Stub")] + public unsafe partial int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest); + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(IStorage* This, uint reserved1, void* reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(IStorage* This, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(IStorage* This, uint reserved1, ref T0 reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(IStorage* This, uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, void* reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, ref T0 reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Proxy")] + public unsafe partial int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(IStorage* This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(IStorage* This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(IStorage* This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(IStorage* This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(IStorage* This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(IStorage* This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, IEnumSTATSTG** ppenum); + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IStorage_EnumElements_Stub")] + public unsafe partial int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum); + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ILockBytes* This, ulong ulOffset, void* pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ILockBytes* This, ulong ulOffset, void* pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ILockBytes* This, ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ILockBytes* This, ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ref ILockBytes This, ulong ulOffset, void* pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ref ILockBytes This, ulong ulOffset, void* pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public unsafe partial int ILockBytesReadAtProxy(ref ILockBytes This, ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Proxy")] + public partial int ILockBytesReadAtProxy(ref ILockBytes This, ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ILockBytes* This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ILockBytes* This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ILockBytes* This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ILockBytes* This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ILockBytes* This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ILockBytes* This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ref ILockBytes This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ref ILockBytes This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ref ILockBytes This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public partial int ILockBytesReadAtStub(ref ILockBytes This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public unsafe partial int ILockBytesReadAtStub(ref ILockBytes This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_ReadAt_Stub")] + public partial int ILockBytesReadAtStub(ref ILockBytes This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead); + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public unsafe partial int ILockBytesWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Proxy")] + public partial int ILockBytesWriteAtProxy(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public partial int ILockBytesWriteAtStub(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public unsafe partial int ILockBytesWriteAtStub(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "ILockBytes_WriteAt_Stub")] + public partial int ILockBytesWriteAtStub(ref ILockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] + public partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] + public partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] + public partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] + public partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] + public partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] + public partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15869, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnViewChange_Proxy")] + public unsafe partial void IAdviseSinkOnViewChangeProxy(IAdviseSink* This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15869, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnViewChange_Proxy")] + public partial void IAdviseSinkOnViewChangeProxy(ref IAdviseSink This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15875, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnViewChange_Stub")] + public unsafe partial int IAdviseSinkOnViewChangeStub(IAdviseSink* This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15875, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnViewChange_Stub")] + public partial int IAdviseSinkOnViewChangeStub(ref IAdviseSink This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Proxy")] + public unsafe partial void IAdviseSinkOnRenameProxy(IAdviseSink* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Proxy")] + public unsafe partial void IAdviseSinkOnRenameProxy(IAdviseSink* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Proxy")] + public unsafe partial void IAdviseSinkOnRenameProxy(ref IAdviseSink This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Proxy")] + public partial void IAdviseSinkOnRenameProxy(ref IAdviseSink This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Stub")] + public unsafe partial int IAdviseSinkOnRenameStub(IAdviseSink* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Stub")] + public unsafe partial int IAdviseSinkOnRenameStub(IAdviseSink* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Stub")] + public unsafe partial int IAdviseSinkOnRenameStub(ref IAdviseSink This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnRename_Stub")] + public partial int IAdviseSinkOnRenameStub(ref IAdviseSink This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15890, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnSave_Proxy")] + public unsafe partial void IAdviseSinkOnSaveProxy(IAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15890, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnSave_Proxy")] + public partial void IAdviseSinkOnSaveProxy(ref IAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15894, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnSave_Stub")] + public unsafe partial int IAdviseSinkOnSaveStub(IAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15894, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnSave_Stub")] + public partial int IAdviseSinkOnSaveStub(ref IAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15897, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnClose_Proxy")] + public unsafe partial void IAdviseSinkOnCloseProxy(IAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15897, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnClose_Proxy")] + public partial void IAdviseSinkOnCloseProxy(ref IAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15901, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnClose_Stub")] + public unsafe partial int IAdviseSinkOnCloseStub(IAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15901, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink_OnClose_Stub")] + public partial int IAdviseSinkOnCloseStub(ref IAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] + public partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] + public partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + + /// To be documented. + [NativeName("Src", "Line 15917, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnDataChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkFinishOnDataChangeProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15917, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnDataChange_Proxy")] + public partial void AsyncIAdviseSinkFinishOnDataChangeProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15921, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnDataChange_Stub")] + public unsafe partial int AsyncIAdviseSinkFinishOnDataChangeStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15921, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnDataChange_Stub")] + public partial int AsyncIAdviseSinkFinishOnDataChangeStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15924, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnViewChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnViewChangeProxy(AsyncIAdviseSink* This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15924, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnViewChange_Proxy")] + public partial void AsyncIAdviseSinkBeginOnViewChangeProxy(ref AsyncIAdviseSink This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15930, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnViewChange_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnViewChangeStub(AsyncIAdviseSink* This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15930, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnViewChange_Stub")] + public partial int AsyncIAdviseSinkBeginOnViewChangeStub(ref AsyncIAdviseSink This, uint dwAspect, int lindex); + + /// To be documented. + [NativeName("Src", "Line 15935, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnViewChange_Proxy")] + public unsafe partial void AsyncIAdviseSinkFinishOnViewChangeProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15935, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnViewChange_Proxy")] + public partial void AsyncIAdviseSinkFinishOnViewChangeProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15939, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnViewChange_Stub")] + public unsafe partial int AsyncIAdviseSinkFinishOnViewChangeStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15939, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnViewChange_Stub")] + public partial int AsyncIAdviseSinkFinishOnViewChangeStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnRenameProxy(AsyncIAdviseSink* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnRenameProxy(AsyncIAdviseSink* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnRenameProxy(ref AsyncIAdviseSink This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Proxy")] + public partial void AsyncIAdviseSinkBeginOnRenameProxy(ref AsyncIAdviseSink This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnRenameStub(AsyncIAdviseSink* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnRenameStub(AsyncIAdviseSink* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnRenameStub(ref AsyncIAdviseSink This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnRename_Stub")] + public partial int AsyncIAdviseSinkBeginOnRenameStub(ref AsyncIAdviseSink This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15952, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnRename_Proxy")] + public unsafe partial void AsyncIAdviseSinkFinishOnRenameProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15952, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnRename_Proxy")] + public partial void AsyncIAdviseSinkFinishOnRenameProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15956, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnRename_Stub")] + public unsafe partial int AsyncIAdviseSinkFinishOnRenameStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15956, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnRename_Stub")] + public partial int AsyncIAdviseSinkFinishOnRenameStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15959, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnSave_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnSaveProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15959, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnSave_Proxy")] + public partial void AsyncIAdviseSinkBeginOnSaveProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15963, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnSave_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnSaveStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15963, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnSave_Stub")] + public partial int AsyncIAdviseSinkBeginOnSaveStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15966, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnSave_Proxy")] + public unsafe partial void AsyncIAdviseSinkFinishOnSaveProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15966, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnSave_Proxy")] + public partial void AsyncIAdviseSinkFinishOnSaveProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15970, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnSave_Stub")] + public unsafe partial int AsyncIAdviseSinkFinishOnSaveStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15970, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnSave_Stub")] + public partial int AsyncIAdviseSinkFinishOnSaveStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15973, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnClose_Proxy")] + public unsafe partial void AsyncIAdviseSinkBeginOnCloseProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15973, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnClose_Proxy")] + public partial void AsyncIAdviseSinkBeginOnCloseProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15977, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnClose_Stub")] + public unsafe partial int AsyncIAdviseSinkBeginOnCloseStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15977, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnClose_Stub")] + public partial int AsyncIAdviseSinkBeginOnCloseStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15980, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnClose_Proxy")] + public unsafe partial void AsyncIAdviseSinkFinishOnCloseProxy(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15980, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnClose_Proxy")] + public partial void AsyncIAdviseSinkFinishOnCloseProxy(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15984, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnClose_Stub")] + public unsafe partial int AsyncIAdviseSinkFinishOnCloseStub(AsyncIAdviseSink* This); + + /// To be documented. + [NativeName("Src", "Line 15984, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink_Finish_OnClose_Stub")] + public partial int AsyncIAdviseSinkFinishOnCloseStub(ref AsyncIAdviseSink This); + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Proxy")] + public unsafe partial void IAdviseSink2OnLinkSrcChangeProxy(IAdviseSink2* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Proxy")] + public unsafe partial void IAdviseSink2OnLinkSrcChangeProxy(IAdviseSink2* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Proxy")] + public unsafe partial void IAdviseSink2OnLinkSrcChangeProxy(ref IAdviseSink2 This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Proxy")] + public partial void IAdviseSink2OnLinkSrcChangeProxy(ref IAdviseSink2 This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Stub")] + public unsafe partial int IAdviseSink2OnLinkSrcChangeStub(IAdviseSink2* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Stub")] + public unsafe partial int IAdviseSink2OnLinkSrcChangeStub(IAdviseSink2* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Stub")] + public unsafe partial int IAdviseSink2OnLinkSrcChangeStub(ref IAdviseSink2 This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IAdviseSink2_OnLinkSrcChange_Stub")] + public partial int IAdviseSink2OnLinkSrcChangeStub(ref IAdviseSink2 This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Proxy")] + public unsafe partial void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(AsyncIAdviseSink2* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Proxy")] + public unsafe partial void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(AsyncIAdviseSink2* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Proxy")] + public unsafe partial void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Proxy")] + public partial void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Stub")] + public unsafe partial int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(AsyncIAdviseSink2* This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Stub")] + public unsafe partial int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(AsyncIAdviseSink2* This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Stub")] + public unsafe partial int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref AsyncIAdviseSink2 This, IMoniker* pmk); + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Begin_OnLinkSrcChange_Stub")] + public partial int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref AsyncIAdviseSink2 This, ref IMoniker pmk); + + /// To be documented. + [NativeName("Src", "Line 16007, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_OnLinkSrcChange_Proxy")] + public unsafe partial void AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(AsyncIAdviseSink2* This); + + /// To be documented. + [NativeName("Src", "Line 16007, Column 38 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_OnLinkSrcChange_Proxy")] + public partial void AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This); + + /// To be documented. + [NativeName("Src", "Line 16011, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_OnLinkSrcChange_Stub")] + public unsafe partial int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(AsyncIAdviseSink2* This); + + /// To be documented. + [NativeName("Src", "Line 16011, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "AsyncIAdviseSink2_Finish_OnLinkSrcChange_Stub")] + public partial int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(ref AsyncIAdviseSink2 This); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] + public partial int IDataObjectGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] + public partial int IDataObjectGetDataStub(ref IDataObject This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium); + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] + public partial int IDataObjectGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] + public partial int IDataObjectGetDataHereStub(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] + public partial int IDataObjectSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] + public partial int IDataObjectSetDataStub(ref IDataObject This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public unsafe partial int IFillLockBytesFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Proxy")] + public partial int IFillLockBytesFillAppendProxy(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public partial int IFillLockBytesFillAppendStub(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public unsafe partial int IFillLockBytesFillAppendStub(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAppend_Stub")] + public partial int IFillLockBytesFillAppendStub(ref IFillLockBytes This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public unsafe partial int IFillLockBytesFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Proxy")] + public partial int IFillLockBytesFillAtProxy(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public unsafe partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + [NativeApi(EntryPoint = "IFillLockBytes_FillAt_Stub")] + public partial int IFillLockBytesFillAtStub(ref IFillLockBytes This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ulong* RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, ref ulong RegHandle); + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public unsafe partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ulong* RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 541, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventRegister")] + public partial uint EventRegister([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, PfnPenablecallback EnableCallback, ref T0 CallbackContext, ref ulong RegHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 555, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventUnregister")] + public partial uint EventUnregister(ulong RegHandle); + + /// To be documented. + [NativeName("Src", "Line 568, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventSetInformation")] + public unsafe partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, void* EventInformation, uint InformationLength); + + /// To be documented. + [NativeName("Src", "Line 568, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventSetInformation")] + public partial uint EventSetInformation(ulong RegHandle, EventInfoClass InformationClass, ref T0 EventInformation, uint InformationLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 611, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventEnabled")] + public unsafe partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor); + + /// To be documented. + [NativeName("Src", "Line 611, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventEnabled")] + public partial byte EventEnabled(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor); + + /// To be documented. + [NativeName("Src", "Line 652, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventProviderEnabled")] + public partial byte EventProviderEnabled(ulong RegHandle, byte Level, ulong Keyword); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public unsafe partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 677, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWrite")] + public partial uint EventWrite(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public unsafe partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 702, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteTransfer")] + public partial uint EventWriteTransfer(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EventDescriptor* EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public unsafe partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, EventDataDescriptor* UserData); + + /// To be documented. + [NativeName("Src", "Line 736, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteEx")] + public partial uint EventWriteEx(ulong RegHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EventDescriptor EventDescriptor, ulong Filter, uint Flags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ActivityId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid RelatedActivityId, uint UserDataCount, ref EventDataDescriptor UserData); + + /// To be documented. + [NativeName("Src", "Line 754, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteString")] + public unsafe partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* String); + + /// To be documented. + [NativeName("Src", "Line 754, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteString")] + public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char String); + + /// To be documented. + [NativeName("Src", "Line 754, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventWriteString")] + public partial uint EventWriteString(ulong RegHandle, byte Level, ulong Keyword, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string String); + + /// To be documented. + [NativeName("Src", "Line 781, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventActivityIdControl")] + public unsafe partial uint EventActivityIdControl(uint ControlCode, Guid* ActivityId); + + /// To be documented. + [NativeName("Src", "Line 781, Column 1 in evntprov.h")] + [NativeApi(EntryPoint = "EventActivityIdControl")] + public partial uint EventActivityIdControl(uint ControlCode, ref Guid ActivityId); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public unsafe partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1671, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceW")] + public partial uint StartTraceW(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ulong* TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public unsafe partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1686, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StartTraceA")] + public partial uint StartTraceA(ref ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public unsafe partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1713, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceW")] + public partial uint StopTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public unsafe partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1728, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "StopTraceA")] + public partial uint StopTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public unsafe partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1754, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceW")] + public partial uint QueryTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public unsafe partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1769, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceA")] + public partial uint QueryTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public unsafe partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1789, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceW")] + public partial uint UpdateTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public unsafe partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1798, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UpdateTraceA")] + public partial uint UpdateTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public unsafe partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1826, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceW")] + public partial uint FlushTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public unsafe partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties); + + /// To be documented. + [NativeName("Src", "Line 1843, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "FlushTraceA")] + public partial uint FlushTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public unsafe partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1862, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceW")] + public partial uint ControlTraceW(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public unsafe partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, EventTraceProperties* Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1878, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ControlTraceA")] + public partial uint ControlTraceA(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string InstanceName, ref EventTraceProperties Properties, uint ControlCode); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1896, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesW")] + public unsafe partial uint QueryAllTracesW(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(EventTraceProperties** PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, uint* LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1905, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryAllTracesA")] + public unsafe partial uint QueryAllTracesA(ref EventTraceProperties* PropertyArray, uint PropertyArrayCount, ref uint LoggerCount); + + /// To be documented. + [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTrace")] + public unsafe partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 1924, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTrace")] + public partial uint EnableTrace(uint Enable, uint EnableFlag, uint EnableLevel, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public unsafe partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, EventFilterDescriptor* EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1946, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx")] + public partial uint EnableTraceEx([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid SourceId, ulong TraceHandle, uint IsEnabled, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint EnableProperty, ref EventFilterDescriptor EnableFilterDesc); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public unsafe partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, EnableTraceParameters* EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 1993, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnableTraceEx2")] + public partial uint EnableTraceEx2(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ProviderId, uint ControlCode, byte Level, ulong MatchAnyKeyword, ulong MatchAllKeyword, uint Timeout, ref EnableTraceParameters EnableParameters); + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public unsafe partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2370, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuidsEx")] + public partial uint EnumerateTraceGuidsEx(TraceQueryInfoClass TraceQueryInfoClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceSetInformation")] + public unsafe partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength); + + /// To be documented. + [NativeName("Src", "Line 2422, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceSetInformation")] + public partial uint TraceSetInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, uint* ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, void* TraceInformation, uint InformationLength, ref uint ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public unsafe partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2434, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceQueryInformation")] + public partial uint TraceQueryInformation(ulong SessionHandle, TraceQueryInfoClass InformationClass, ref T0 TraceInformation, uint InformationLength, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public unsafe partial uint CreateTraceInstanceId(void* RegHandle, EventInstanceInfo* InstInfo); + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public unsafe partial uint CreateTraceInstanceId(void* RegHandle, ref EventInstanceInfo InstInfo); + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public unsafe partial uint CreateTraceInstanceId(ref T0 RegHandle, EventInstanceInfo* InstInfo) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2456, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CreateTraceInstanceId")] + public partial uint CreateTraceInstanceId(ref T0 RegHandle, ref EventInstanceInfo InstInfo) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEvent")] + public unsafe partial uint TraceEvent(ulong TraceHandle, EventTraceHeader* EventTrace); + + /// To be documented. + [NativeName("Src", "Line 2474, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEvent")] + public partial uint TraceEvent(ulong TraceHandle, ref EventTraceHeader EventTrace); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, EventInstanceHeader* EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, EventInstanceInfo* InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public unsafe partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, EventInstanceInfo* ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2488, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceEventInstance")] + public partial uint TraceEventInstance(ulong TraceHandle, ref EventInstanceHeader EventTrace, ref EventInstanceInfo InstInfo, ref EventInstanceInfo ParentInstInfo); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public unsafe partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2522, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsW")] + public partial uint RegisterTraceGuidsW(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, void* RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, TraceGuidRegistration* TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public unsafe partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ulong* RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2542, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RegisterTraceGuidsA")] + public partial uint RegisterTraceGuidsA(PfnWmidprequest RequestAddress, ref T0 RequestContext, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid ControlGuid, uint GuidCount, ref TraceGuidRegistration TraceGuidReg, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofImagePath, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string MofResourceName, ref ulong RegistrationHandle) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(TraceGuidProperties** GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, uint* GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2557, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "EnumerateTraceGuids")] + public unsafe partial uint EnumerateTraceGuids(ref TraceGuidProperties* GuidPropertiesArray, uint PropertyArrayCount, ref uint GuidCount); + + /// To be documented. + [NativeName("Src", "Line 2573, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "UnregisterTraceGuids")] + public partial uint UnregisterTraceGuids(ulong RegistrationHandle); + + /// To be documented. + [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceLoggerHandle")] + public unsafe partial ulong GetTraceLoggerHandle(void* Buffer); + + /// To be documented. + [NativeName("Src", "Line 2580, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceLoggerHandle")] + public partial ulong GetTraceLoggerHandle(ref T0 Buffer) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2587, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceEnableLevel")] + public partial byte GetTraceEnableLevel(ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 2594, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "GetTraceEnableFlags")] + public partial uint GetTraceEnableFlags(ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceW")] + public unsafe partial ulong OpenTraceW(EventTraceLogfilew* Logfile); + + /// To be documented. + [NativeName("Src", "Line 2619, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceW")] + public partial ulong OpenTraceW(ref EventTraceLogfilew Logfile); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ulong* HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, Filetime* StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public unsafe partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, Filetime* EndTime); + + /// To be documented. + [NativeName("Src", "Line 2627, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTrace")] + public partial uint ProcessTrace(ref ulong HandleArray, uint HandleCount, ref Filetime StartTime, ref Filetime EndTime); + + /// To be documented. + [NativeName("Src", "Line 2638, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "CloseTrace")] + public partial uint CloseTrace(ulong TraceHandle); + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public unsafe partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, void* BufferCompletionContext); + + /// To be documented. + [NativeName("Src", "Line 2647, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromBufferStream")] + public partial ulong OpenTraceFromBufferStream([Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, PfnPetwBufferCompletionCallback BufferCompletionCallback, ref T0 BufferCompletionContext) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public unsafe partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2658, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLogger")] + public partial ulong OpenTraceFromRealTimeLogger([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, void* MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public unsafe partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, TraceLogfileHeader* LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2669, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromRealTimeLoggerWithAllocationOptions")] + public partial ulong OpenTraceFromRealTimeLoggerWithAllocationOptions([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LoggerName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, nuint AllocationSize, ref T0 MemoryPartitionHandle, ref TraceLogfileHeader LogFileHeader) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwOpenTraceOptions* Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public unsafe partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, TraceLogfileHeader* LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2682, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceFromFile")] + public partial ulong OpenTraceFromFile([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string LogFileName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwOpenTraceOptions Options, ref TraceLogfileHeader LogFileHeader); + + /// To be documented. + [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] + public unsafe partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + + /// To be documented. + [NativeName("Src", "Line 2693, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferIncrementReference")] + public partial uint ProcessTraceBufferIncrementReference(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwBufferHeader Buffer); + + /// To be documented. + [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] + public unsafe partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer); + + /// To be documented. + [NativeName("Src", "Line 2703, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceBufferDecrementReference")] + public partial uint ProcessTraceBufferDecrementReference([Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwBufferHeader Buffer); + + /// To be documented. + [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] + public unsafe partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] EtwBufferHeader* Buffer, uint BufferSize); + + /// To be documented. + [NativeName("Src", "Line 2712, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "ProcessTraceAddBufferToBufferStream")] + public partial uint ProcessTraceAddBufferToBufferStream(ulong TraceHandle, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in EtwBufferHeader Buffer, uint BufferSize); + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength); + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, void* InBuffer, uint InBufferSize, ref T0 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, void* OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public unsafe partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, uint* ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2749, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "QueryTraceProcessingHandle")] + public partial uint QueryTraceProcessingHandle(ulong ProcessingHandle, EtwProcessHandleInfoType InformationClass, ref T0 InBuffer, uint InBufferSize, ref T1 OutBuffer, uint OutBufferSize, ref uint ReturnLength) where T0 : unmanaged where T1 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceA")] + public unsafe partial ulong OpenTraceA(EventTraceLogfilea* Logfile); + + /// To be documented. + [NativeName("Src", "Line 2779, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "OpenTraceA")] + public partial ulong OpenTraceA(ref EventTraceLogfilea Logfile); + + /// To be documented. + [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "SetTraceCallback")] + public unsafe partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid, PfnPeventCallback EventCallback); + + /// To be documented. + [NativeName("Src", "Line 2786, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "SetTraceCallback")] + public partial uint SetTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pGuid, PfnPeventCallback EventCallback); + + /// To be documented. + [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RemoveTraceCallback")] + public unsafe partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pGuid); + + /// To be documented. + [NativeName("Src", "Line 2794, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "RemoveTraceCallback")] + public partial uint RemoveTraceCallback([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pGuid); + + /// To be documented. + [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessage")] + public unsafe partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber); + + /// To be documented. + [NativeName("Src", "Line 2811, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessage")] + public partial uint TraceMessage(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, byte* MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, ref byte MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public unsafe partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber, byte* MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber, ref byte MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 2827, Column 1 in evntrace.h")] + [NativeApi(EntryPoint = "TraceMessageVa")] + public partial uint TraceMessageVa(ulong LoggerHandle, uint MessageFlags, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid MessageGuid, ushort MessageNumber, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string MessageArgList); + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, char* lpBuffer, string[] lpFilePartSa) { // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 727, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 742, Column 1 in fileapi.h")] + public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + { + // StringArrayOverloader + var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); + var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); + SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); + SilkMarshal.Free((nint) lpFilePart); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] + public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] + public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] + public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] + public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] + public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] + public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] + public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] + public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(ref This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] + public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextProxy(ref This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(ref This, celt, rgelt, pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] + public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + { + // StringArrayOverloader + var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); + var ret = IEnumStringNextStub(ref This, celt, rgelt, ref pceltFetched); + SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); + SilkMarshal.Free((nint) rgelt); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] + public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] + public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] + public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] + public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] + public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] + public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] + public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] + public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteSetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public unsafe void IBindCtxRemoteGetBindOptionsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IBindCtxRemoteGetBindOptionsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public unsafe int IEnumMonikerRemoteNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerRemoteNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public unsafe void IEnumMonikerRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumMonikerRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9611, Column 43 in objidl.h")] + public unsafe int IRunnableObjectRemoteIsRunningProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IRunnableObjectRemoteIsRunningProxy((IRunnableObject*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public unsafe void IRunnableObjectRemoteIsRunningStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IRunnableObjectRemoteIsRunningStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToObjectStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToObjectStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe int IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public unsafe void IMonikerRemoteBindToStorageStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IMonikerRemoteBindToStorageStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGRemoteNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGRemoteNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public unsafe void IEnumSTATSTGRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATSTGRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public unsafe int IStorageRemoteOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteOpenStreamProxy(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public unsafe void IStorageRemoteOpenStreamStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteOpenStreamStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public unsafe int IStorageRemoteCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteCopyToProxy(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public unsafe void IStorageRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public unsafe int IStorageRemoteEnumElementsProxy(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageRemoteEnumElementsProxy(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public unsafe void IStorageRemoteEnumElementsStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IStorageRemoteEnumElementsStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public unsafe int ILockBytesRemoteReadAtProxy(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteReadAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteReadAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public unsafe int ILockBytesRemoteWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return ILockBytesRemoteWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ILockBytesRemoteWriteAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumFORMATETCRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IEnumSTATDATARemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12255, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnViewChangeProxy((IAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnRenameProxy((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnRenameProxy((IAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnRenameProxy(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12280, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnSaveProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12291, Column 43 in objidl.h")] + public unsafe int IAdviseSinkRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSinkRemoteOnCloseProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12494, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12505, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnViewChangeProxy((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12518, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnViewChangeProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12541, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnRenameProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnRenameProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12552, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnSaveProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12563, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnSaveProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12574, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkBeginRemoteOnCloseProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12585, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishRemoteOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSinkFinishRemoteOnCloseProxy((AsyncIAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2RemoteOnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2RemoteOnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IAdviseSink2RemoteOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSink2RemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, ref pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12938, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteGetDataHereStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public unsafe void IDataObjectRemoteSetDataStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IDataObjectRemoteSetDataStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAppendStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAppendStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public unsafe int IFillLockBytesRemoteFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IFillLockBytesRemoteFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IFillLockBytesRemoteFillAtStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, TagBINDOPTS* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, ref TagBINDOPTS pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, TagBINDOPTS* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, ref TagBINDOPTS pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public unsafe int IEnumMonikerNextProxy(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextProxy(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ComPtr This, uint celt, ref IMoniker* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub((IEnumMoniker*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public unsafe int IEnumMonikerNextStub(ref IEnumMoniker This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumMonikerNextStub(ref This, celt, (IMoniker**) rgelt.GetAddressOf(), ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15673, Column 38 in objidl.h")] + public unsafe Silk.NET.Core.Bool32 IRunnableObjectIsRunningProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IRunnableObjectIsRunningProxy((IRunnableObject*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15677, Column 43 in objidl.h")] + public unsafe int IRunnableObjectIsRunningStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IRunnableObjectIsRunningStub((IRunnableObject*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, void** ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref void* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe int IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvResult = default; + return IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe int IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riidResult, ref ComPtr ppvResult) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, ref riidResult, (Silk.NET.Core.Native.IUnknown**) ppvResult.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, void** ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref void* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageProxy(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe int IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (void**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub((IMoniker*) This.Handle, ref pbc, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, (IBindCtx*) pbc.Handle, ref pmkToLeft, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft, ref Guid riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, (IMoniker*) pmkToLeft.Handle, ref riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, out ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + ppvObj = default; + return IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, SilkMarshal.GuidPtrOf(), (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe int IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft, ref Guid riid, ref ComPtr ppvObj) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, ref riid, (Silk.NET.Core.Native.IUnknown**) ppvObj.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public unsafe int IEnumSTATSTGNextProxy(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextProxy((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, STATSTG* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, STATSTG* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, ref STATSTG rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public unsafe int IEnumSTATSTGNextStub(ComPtr This, uint celt, ref STATSTG rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IEnumSTATSTGNextStub((IEnumSTATSTG*) This.Handle, celt, ref rgelt, ref pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, in pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy((IStorage*) This.Handle, pwcsName, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, in pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, in pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public unsafe int IStorageOpenStreamProxy(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, ref T0 reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamProxy(ref This, pwcsName, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub((IStorage*) This.Handle, pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, in pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, ref byte reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, ref reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public unsafe int IStorageOpenStreamStub(ref IStorage This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageOpenStreamStub(ref This, pwcsName, cbReserved1, reserved1, grfMode, reserved2, (Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); return ret; } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, ref char lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) { // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); return ret; } /// To be documented. - [NativeName("Src", "Line 727, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameW([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) { // StringArrayOverloader - var lpFilePart = (char**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameW(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); return ret; } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) { // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public unsafe int IStorageCopyToProxy(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToProxy(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ComPtr This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ref IStorage pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub((IStorage*) This.Handle, ciidExclude, in rgiidExclude, ref snbExclude, ref pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, IStorage* pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, char** snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, string[] snbExcludeSa, ref IStorage pstgDest) + { + // StringArrayOverloader + var snbExclude = (char**) SilkMarshal.StringArrayToPtr(snbExcludeSa); + var ret = IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, snbExclude, ref pstgDest); + SilkMarshal.CopyPtrToStringArray((nint) snbExclude, snbExcludeSa); + SilkMarshal.Free((nint) snbExclude); return ret; } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public unsafe int IStorageCopyToStub(ref IStorage This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid rgiidExclude, ref char* snbExclude, ComPtr pstgDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageCopyToStub(ref This, ciidExclude, in rgiidExclude, ref snbExclude, (IStorage*) pstgDest.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ComPtr This, uint reserved1, ref T0 reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy((IStorage*) This.Handle, reserved1, ref reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, void* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy(ref This, reserved1, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public unsafe int IStorageEnumElementsProxy(ref IStorage This, uint reserved1, ref T0 reserved2, uint reserved3, ref ComPtr ppenum) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsProxy(ref This, reserved1, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, ref reserved2, reserved3, ref ppenum); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ComPtr This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(in lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub((IStorage*) This.Handle, reserved1, cbReserved2, reserved2, reserved3, ref ppenum); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(in lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, byte* lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, ref byte reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, ref reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, ref byte lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public unsafe int IStorageEnumElementsStub(ref IStorage This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref ComPtr ppenum) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, ref lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return IStorageEnumElementsStub(ref This, reserved1, cbReserved2, reserved2, reserved3, (IEnumSTATSTG**) ppenum.GetAddressOf()); } /// To be documented. - [NativeName("Src", "Line 742, Column 1 in fileapi.h")] - public unsafe uint GetFullPathNameA([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpFileName, uint nBufferLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPStr)] string lpBuffer, string[] lpFilePartSa) + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var lpFilePart = (byte**) SilkMarshal.StringArrayToPtr(lpFilePartSa); - var ret = GetFullPathNameA(lpFileName, nBufferLength, lpBuffer, lpFilePart); - SilkMarshal.CopyPtrToStringArray((nint) lpFilePart, lpFilePartSa); - SilkMarshal.Free((nint) lpFilePart); - return ret; + // ComPtrOverloader + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public unsafe int ILockBytesReadAtProxy(ComPtr This, ulong ulOffset, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + return ILockBytesReadAtProxy((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); } /// To be documented. - [NativeName("Src", "Line 2005, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownRemoteNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownRemoteNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, ref pv, cb, pcbRead); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, ref pv, cb, ref pcbRead); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbRead); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public unsafe int ILockBytesReadAtStub(ComPtr This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ILockBytesReadAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbRead); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public unsafe int ILockBytesWriteAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return ILockBytesWriteAtProxy((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2012, Column 17 in objidlbase.h")] - public unsafe void IEnumUnknownRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumUnknownRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return ILockBytesWriteAtStub((ILockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringRemoteNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2144, Column 43 in objidlbase.h")] - public unsafe int IEnumStringRemoteNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringRemoteNextProxy(ref This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2151, Column 17 in objidlbase.h")] - public unsafe void IEnumStringRemoteNextStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IEnumStringRemoteNextStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2273, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteReadProxy(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15869, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + IAdviseSinkOnViewChangeProxy((IAdviseSink*) This.Handle, dwAspect, lindex); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15875, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnViewChangeStub(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return IAdviseSinkOnViewChangeStub((IAdviseSink*) This.Handle, dwAspect, lindex); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + IAdviseSinkOnRenameProxy((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + IAdviseSinkOnRenameProxy((IAdviseSink*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnRenameProxy(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + IAdviseSinkOnRenameProxy(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnRenameStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return IAdviseSinkOnRenameStub((IAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnRenameStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return IAdviseSinkOnRenameStub((IAdviseSink*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnRenameStub(ref IAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return IAdviseSinkOnRenameStub(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15890, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + IAdviseSinkOnSaveProxy((IAdviseSink*) This.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 15894, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return IAdviseSinkOnSaveStub((IAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15897, Column 38 in objidl.h")] + public unsafe void IAdviseSinkOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + IAdviseSinkOnCloseProxy((IAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15901, Column 43 in objidl.h")] + public unsafe int IAdviseSinkOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return IAdviseSinkOnCloseStub((IAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2280, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteReadStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteReadStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); } /// To be documented. - [NativeName("Src", "Line 2287, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamRemoteWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamRemoteWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15917, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnDataChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkFinishOnDataChangeProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15921, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnDataChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkFinishOnDataChangeStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15924, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnViewChangeProxy(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkBeginOnViewChangeProxy((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15930, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnViewChangeStub(ComPtr This, uint dwAspect, int lindex) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkBeginOnViewChangeStub((AsyncIAdviseSink*) This.Handle, dwAspect, lindex); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15935, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnViewChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkFinishOnViewChangeProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15939, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnViewChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkFinishOnViewChangeStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkBeginOnRenameProxy((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + AsyncIAdviseSinkBeginOnRenameProxy((AsyncIAdviseSink*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnRenameProxy(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkBeginOnRenameProxy(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkBeginOnRenameStub((AsyncIAdviseSink*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return AsyncIAdviseSinkBeginOnRenameStub((AsyncIAdviseSink*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2294, Column 17 in objidlbase.h")] - public unsafe void ISequentialStreamRemoteWriteStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnRenameStub(ref AsyncIAdviseSink This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - ISequentialStreamRemoteWriteStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkBeginOnRenameStub(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15952, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnRenameProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + AsyncIAdviseSinkFinishOnRenameProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2568, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15956, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnRenameStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + return AsyncIAdviseSinkFinishOnRenameStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15959, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkBeginOnSaveProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15963, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkBeginOnSaveStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15966, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnSaveProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkFinishOnSaveProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15970, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnSaveStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkFinishOnSaveStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15973, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkBeginOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkBeginOnCloseProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15977, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkBeginOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkBeginOnCloseStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15980, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSinkFinishOnCloseProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + AsyncIAdviseSinkFinishOnCloseProxy((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15984, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSinkFinishOnCloseStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return AsyncIAdviseSinkFinishOnCloseStub((AsyncIAdviseSink*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + IAdviseSink2OnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + IAdviseSink2OnLinkSrcChangeProxy((IAdviseSink2*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public unsafe void IAdviseSink2OnLinkSrcChangeProxy(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + IAdviseSink2OnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2575, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteSeekStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public unsafe int IAdviseSink2OnLinkSrcChangeStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteSeekStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return IAdviseSink2OnLinkSrcChangeStub((IAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public unsafe int IAdviseSink2OnLinkSrcChangeStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + return IAdviseSink2OnLinkSrcChangeStub((IAdviseSink2*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public unsafe int IAdviseSink2OnLinkSrcChangeStub(ref IAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return IAdviseSink2OnLinkSrcChangeStub(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + AsyncIAdviseSink2BeginOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + AsyncIAdviseSink2BeginOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ComPtr This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + return AsyncIAdviseSink2BeginOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ComPtr This, ref IMoniker pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + return AsyncIAdviseSink2BeginOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle, ref pmk); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref AsyncIAdviseSink2 This, ComPtr pmk) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + return AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref This, (IMoniker*) pmk.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16007, Column 38 in objidl.h")] + public unsafe void AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + AsyncIAdviseSink2FinishOnLinkSrcChangeProxy((AsyncIAdviseSink2*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16011, Column 43 in objidl.h")] + public unsafe int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(ComPtr This) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + return AsyncIAdviseSink2FinishOnLinkSrcChangeStub((AsyncIAdviseSink2*) This.Handle); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pmedium); } /// To be documented. - [NativeName("Src", "Line 2582, Column 43 in objidlbase.h")] - public unsafe int IStreamRemoteCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IStreamRemoteCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataStub(ComPtr This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase); + return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, _pdwStubPhase); + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ComPtr This, ref IRpcChannelBuffer _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub((IRpcStubBuffer*) This.Handle, ref _pRpcChannelBuffer, ref _pRpcMessage, ref _pdwStubPhase); + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, _pdwStubPhase); + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, RPCMessage* _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, _pRpcMessage, ref _pdwStubPhase); + return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, uint* _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, _pdwStubPhase); + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 2590, Column 17 in objidlbase.h")] - public unsafe void IStreamRemoteCopyToStub(ref IRpcStubBuffer This, ComPtr _pRpcChannelBuffer, ref RPCMessage _pRpcMessage, ref uint _pdwStubPhase) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - IStreamRemoteCopyToStub(ref This, (IRpcChannelBuffer*) _pRpcChannelBuffer.Handle, ref _pRpcMessage, ref _pdwStubPhase); + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8449, Column 41 in objidlbase.h")] - public unsafe int IEnumUnknownNextProxy(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public unsafe int IDataObjectSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextProxy(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, pceltFetched); + return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ComPtr This, uint celt, ref Silk.NET.Core.Native.IUnknown* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public unsafe int IDataObjectSetDataStub(ComPtr This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub((IEnumUnknown*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), pceltFetched); + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8459, Column 43 in objidlbase.h")] - public unsafe int IEnumUnknownNextStub(ref IEnumUnknown This, uint celt, ref ComPtr rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumUnknownNextStub(ref This, celt, (Silk.NET.Core.Native.IUnknown**) rgelt.GetAddressOf(), ref pceltFetched); + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAppendProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + return IFillLockBytesFillAppendProxy((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, in pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextProxy((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, in pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(ref This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8465, Column 41 in objidlbase.h")] - public unsafe int IEnumStringNextProxy(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAppendStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextProxy(ref This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAppendStub((IFillLockBytes*) This.Handle, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, pceltFetched); + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(IEnumString* This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, char** rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public unsafe int IFillLockBytesFillAtProxy(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, rgelt, ref pceltFetched); + return IFillLockBytesFillAtProxy((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, pceltFetched); + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ComPtr This, uint celt, ref char* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return IEnumStringNextStub((IEnumString*) This.Handle, celt, ref rgelt, ref pceltFetched); + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, uint* pceltFetched) + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(ref This, celt, rgelt, pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8474, Column 43 in objidlbase.h")] - public unsafe int IEnumStringNextStub(ref IEnumString This, uint celt, string[] rgeltSa, ref uint pceltFetched) + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { - // StringArrayOverloader - var rgelt = (char**) SilkMarshal.StringArrayToPtr(rgeltSa); - var ret = IEnumStringNextStub(ref This, celt, rgelt, ref pceltFetched); - SilkMarshal.CopyPtrToStringArray((nint) rgelt, rgeltSa); - SilkMarshal.Free((nint) rgelt); - return ret; + // ComPtrOverloader + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, in pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, pcbRead); + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, void* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public unsafe int IFillLockBytesFillAtStub(ComPtr This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + return IFillLockBytesFillAtStub((IFillLockBytes*) This.Handle, ulOffset, pv, cb, ref pcbWritten); } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8480, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamReadProxy(ComPtr This, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadProxy((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, byte* pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(ref This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, ref byte pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, ref pv, cb, ref pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(ref This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(ref This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8490, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamReadStub(ComPtr This, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbRead) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamReadStub((ISequentialStream*) This.Handle, pv, cb, ref pcbRead); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8496, Column 41 in objidlbase.h")] - public unsafe int ISequentialStreamWriteProxy(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteProxy((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(ref This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(ref This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(ref This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerRemoteBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, in pv, cb, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerRemoteBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8506, Column 43 in objidlbase.h")] - public unsafe int ISequentialStreamWriteStub(ComPtr This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, ref uint pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { - // ComPtrOverloader - return ISequentialStreamWriteStub((ISequentialStream*) This.Handle, pv, cb, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] - public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8512, Column 41 in objidlbase.h")] - public unsafe int IStreamSeekProxy(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamSeekProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] - public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ulong* plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, plibNewPosition); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(ref This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8520, Column 43 in objidlbase.h")] - public unsafe int IStreamSeekStub(ComPtr This, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamSeekStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, dlibMove, dwOrigin, ref plibNewPosition); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(ref This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(ref This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectProxy(ref This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(ref This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(ref This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(ref This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToObjectStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToObjectStub(ref This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8526, Column 41 in objidlbase.h")] - public unsafe int IStreamCopyToProxy(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToProxy(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(ref This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(ref This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(ref This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageProxy(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageProxy(ref This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl where TI3 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ComPtr This, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ComPtr This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub((Silk.NET.Core.Win32Extras.IStream*) This.Handle, ref pstm, cb, ref pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ComPtr This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(ref This, pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; } /// To be documented. - [NativeName("Src", "Line 8537, Column 43 in objidlbase.h")] - public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream This, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ref IMoniker This, ComPtr pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { - // ComPtrOverloader - return IStreamCopyToStub(ref This, (Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(ref This, pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ComPtr pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(ref This, ref pbc, pmkToLeft, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public unsafe ComPtr IMonikerBindToStorageStub(ref IMoniker This, ref IBindCtx pbc, ref IMoniker pmkToLeft) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(IMonikerBindToStorageStub(ref This, ref pbc, ref pmkToLeft, out ComPtr silkRet)); + return silkRet; } diff --git a/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs index b335dd7e67..cdbc9819cb 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs @@ -10904,6 +10904,13142 @@ public static unsafe int IStreamCopyToStub(this Windows thisApi, SpanTo be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxRemoteSetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxRemoteSetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9306, Column 43 in objidl.h")] + public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxRemoteSetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9311, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteSetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxRemoteGetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxRemoteGetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 9318, Column 43 in objidl.h")] + public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxRemoteGetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9323, Column 17 in objidl.h")] + public static unsafe void IBindCtxRemoteGetBindOptionsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IBindCtxRemoteGetBindOptionsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerRemoteNextProxy(this Windows thisApi, IEnumMoniker* This, uint celt, IMoniker** rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerRemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerRemoteNextProxy(this Windows thisApi, IEnumMoniker* This, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerRemoteNextProxy(This, celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerRemoteNextProxy(this Windows thisApi, Span This, uint celt, IMoniker** rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerRemoteNextProxy(this Windows thisApi, Span This, uint celt, IMoniker** rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerRemoteNextProxy(this Windows thisApi, Span This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 9455, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerRemoteNextProxy(this Windows thisApi, Span This, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9462, Column 17 in objidl.h")] + public static unsafe void IEnumMonikerRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumMonikerRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9611, Column 43 in objidl.h")] + public static unsafe int IRunnableObjectRemoteIsRunningProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IRunnableObjectRemoteIsRunningProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 9615, Column 17 in objidl.h")] + public static unsafe void IRunnableObjectRemoteIsRunningStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IRunnableObjectRemoteIsRunningStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10382, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10390, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToObjectStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToObjectStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10397, Column 43 in objidl.h")] + public static unsafe int IMonikerRemoteBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerRemoteBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10405, Column 17 in objidl.h")] + public static unsafe void IMonikerRemoteBindToStorageStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IMonikerRemoteBindToStorageStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, IEnumSTATSTG* This, uint celt, STATSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, IEnumSTATSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, IEnumSTATSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, STATSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, STATSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 10649, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 10656, Column 17 in objidl.h")] + public static unsafe void IEnumSTATSTGRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATSTGRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 10998, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageRemoteOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11008, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteOpenStreamStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteOpenStreamStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(This, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 11015, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageRemoteCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11023, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteCopyToStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteCopyToStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, IStorage* This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(This, reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, IStorage* This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(This, reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(ref This.GetPinnableReference(), reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(ref This.GetPinnableReference(), reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11030, Column 43 in objidl.h")] + public static unsafe int IStorageRemoteEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageRemoteEnumElementsProxy(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11039, Column 17 in objidl.h")] + public static unsafe void IStorageRemoteEnumElementsStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IStorageRemoteEnumElementsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, byte* pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(This, ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, Span pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(This, ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, Span pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(This, ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(This, ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, byte* pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, Span pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(ref This.GetPinnableReference(), ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, Span pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(ref This.GetPinnableReference(), ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 11539, Column 35 in objidl.h")] + public static unsafe int ILockBytesRemoteReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesRemoteReadAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11547, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteReadAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteReadAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 11554, Column 43 in objidl.h")] + public static unsafe int ILockBytesRemoteWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesRemoteWriteAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11562, Column 17 in objidl.h")] + public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.ILockBytesRemoteWriteAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11719, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11726, Column 17 in objidl.h")] + public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumFORMATETCRemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 11880, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 11887, Column 17 in objidl.h")] + public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IEnumSTATDATARemoteNextStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12242, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12248, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12255, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnViewChangeProxy(this Windows thisApi, Span This, uint dwAspect, int lindex) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnViewChangeProxy(ref This.GetPinnableReference(), dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12261, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnRenameProxy(this Windows thisApi, IAdviseSink* This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnRenameProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnRenameProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnRenameProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12268, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnRenameProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnRenameProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12273, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12280, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnSaveProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnSaveProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12284, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12291, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkRemoteOnCloseProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IAdviseSinkRemoteOnCloseProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12295, Column 17 in objidl.h")] + public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSinkRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 12481, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12487, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12494, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12498, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnDataChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnDataChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12505, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(this Windows thisApi, Span This, uint dwAspect, int lindex) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeProxy(ref This.GetPinnableReference(), dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12511, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12518, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12522, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnViewChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnViewChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnRenameProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12529, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnRenameProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnRenameProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12534, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12541, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishRemoteOnRenameProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishRemoteOnRenameProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12545, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnRenameStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnRenameStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12552, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnSaveProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnSaveProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12556, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12563, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishRemoteOnSaveProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishRemoteOnSaveProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12567, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnSaveStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnSaveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12574, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginRemoteOnCloseProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginRemoteOnCloseProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12578, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12585, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishRemoteOnCloseProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishRemoteOnCloseProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12589, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishRemoteOnCloseStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishRemoteOnCloseStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public static unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(this Windows thisApi, IAdviseSink2* This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSink2RemoteOnLinkSrcChangeProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public static unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.IAdviseSink2RemoteOnLinkSrcChangeProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12740, Column 43 in objidl.h")] + public static unsafe int IAdviseSink2RemoteOnLinkSrcChangeProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSink2RemoteOnLinkSrcChangeProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12745, Column 17 in objidl.h")] + public static unsafe void IAdviseSink2RemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IAdviseSink2RemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(this Windows thisApi, AsyncIAdviseSink2* This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 12926, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12931, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12938, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 12942, Column 17 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(This, pformatetcIn, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13172, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13178, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(This, pformatetc, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 13185, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13191, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteGetDataHereStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(This, pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(This, ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13198, Column 43 in objidl.h")] + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13205, Column 17 in objidl.h")] + public static unsafe void IDataObjectRemoteSetDataStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IDataObjectRemoteSetDataStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(This, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(This, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(This, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(This, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(ref This.GetPinnableReference(), pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(ref This.GetPinnableReference(), pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(ref This.GetPinnableReference(), in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(ref This.GetPinnableReference(), in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(ref This.GetPinnableReference(), pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13830, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAppendProxy(ref This.GetPinnableReference(), pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13837, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAppendStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAppendStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 13844, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesRemoteFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesRemoteFillAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 13852, Column 17 in objidl.h")] + public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IFillLockBytesRemoteFillAtStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15463, Column 39 in objidl.h")] + public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15464, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15465, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.ASYNCSTGMEDIUMUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + { + // SpanOverloader + thisApi.ASYNCSTGMEDIUMUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15466, Column 39 in objidl.h")] + public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.ASYNCSTGMEDIUMUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + public static unsafe uint CLIPFORMATUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + public static unsafe uint CLIPFORMATUserSize(this Windows thisApi, Span arg0, uint arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15468, Column 39 in objidl.h")] + public static unsafe uint CLIPFORMATUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, Span arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15469, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15470, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + public static unsafe void CLIPFORMATUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + public static unsafe void CLIPFORMATUserFree(this Windows thisApi, Span arg0, ushort* arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15471, Column 39 in objidl.h")] + public static unsafe void CLIPFORMATUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + public static unsafe uint FLAGSTGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + public static unsafe uint FLAGSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15473, Column 39 in objidl.h")] + public static unsafe uint FLAGSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15474, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15475, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + public static unsafe void FLAGSTGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.FLAGSTGMEDIUMUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + public static unsafe void FLAGSTGMEDIUMUserFree(this Windows thisApi, Span arg0, FlagStgmedium* arg1) + { + // SpanOverloader + thisApi.FLAGSTGMEDIUMUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15476, Column 39 in objidl.h")] + public static unsafe void FLAGSTGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.FLAGSTGMEDIUMUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15478, Column 39 in objidl.h")] + public static unsafe uint HBITMAPUserSize(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15478, Column 39 in objidl.h")] + public static unsafe uint HBITMAPUserSize(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15479, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15480, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15481, Column 39 in objidl.h")] + public static unsafe void HBITMAPUserFree(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HBITMAPUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15481, Column 39 in objidl.h")] + public static unsafe void HBITMAPUserFree(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HBITMAPUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + public static unsafe uint HDCUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + public static unsafe uint HDCUserSize(this Windows thisApi, Span arg0, uint arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15483, Column 39 in objidl.h")] + public static unsafe uint HDCUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15484, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15485, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + public static unsafe void HDCUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.HDCUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + public static unsafe void HDCUserFree(this Windows thisApi, Span arg0, nint* arg1) + { + // SpanOverloader + thisApi.HDCUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15486, Column 39 in objidl.h")] + public static unsafe void HDCUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.HDCUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15488, Column 39 in objidl.h")] + public static unsafe uint HICONUserSize(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15488, Column 39 in objidl.h")] + public static unsafe uint HICONUserSize(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15489, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15490, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15491, Column 39 in objidl.h")] + public static unsafe void HICONUserFree(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HICONUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15491, Column 39 in objidl.h")] + public static unsafe void HICONUserFree(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HICONUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15493, Column 39 in objidl.h")] + public static unsafe uint SNBUserSize(this Windows thisApi, Span arg0, uint arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15493, Column 39 in objidl.h")] + public static unsafe uint SNBUserSize(this Windows thisApi, Span arg0, uint arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, uint* arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, uint* arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, Span arg0, byte* arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, Span arg0, byte* arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, Span arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, Span arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15494, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15495, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15496, Column 39 in objidl.h")] + public static unsafe void SNBUserFree(this Windows thisApi, Span arg0, char*** arg1) + { + // SpanOverloader + thisApi.SNBUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15496, Column 39 in objidl.h")] + public static unsafe void SNBUserFree(this Windows thisApi, Span arg0, ref char** arg1) + { + // SpanOverloader + thisApi.SNBUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15498, Column 39 in objidl.h")] + public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15499, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15500, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + public static unsafe void STGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.STGMEDIUMUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + { + // SpanOverloader + thisApi.STGMEDIUMUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15501, Column 39 in objidl.h")] + public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.STGMEDIUMUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15503, Column 39 in objidl.h")] + public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15504, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15505, Column 29 in objidl.h")] + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.ASYNCSTGMEDIUMUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + { + // SpanOverloader + thisApi.ASYNCSTGMEDIUMUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15506, Column 39 in objidl.h")] + public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.ASYNCSTGMEDIUMUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + public static unsafe uint CLIPFORMATUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + public static unsafe uint CLIPFORMATUserSize64(this Windows thisApi, Span arg0, uint arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15508, Column 39 in objidl.h")] + public static unsafe uint CLIPFORMATUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15509, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15510, Column 29 in objidl.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + public static unsafe void CLIPFORMATUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + public static unsafe void CLIPFORMATUserFree64(this Windows thisApi, Span arg0, ushort* arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15511, Column 39 in objidl.h")] + public static unsafe void CLIPFORMATUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + public static unsafe uint FLAGSTGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + public static unsafe uint FLAGSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15513, Column 39 in objidl.h")] + public static unsafe uint FLAGSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15514, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, FlagStgmedium* arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15515, Column 29 in objidl.h")] + public static unsafe byte* FLAGSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.FLAGSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + public static unsafe void FLAGSTGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.FLAGSTGMEDIUMUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + public static unsafe void FLAGSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, FlagStgmedium* arg1) + { + // SpanOverloader + thisApi.FLAGSTGMEDIUMUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15516, Column 39 in objidl.h")] + public static unsafe void FLAGSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.FLAGSTGMEDIUMUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15518, Column 39 in objidl.h")] + public static unsafe uint HBITMAPUserSize64(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15518, Column 39 in objidl.h")] + public static unsafe uint HBITMAPUserSize64(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15519, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15520, Column 29 in objidl.h")] + public static unsafe byte* HBITMAPUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15521, Column 39 in objidl.h")] + public static unsafe void HBITMAPUserFree64(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HBITMAPUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15521, Column 39 in objidl.h")] + public static unsafe void HBITMAPUserFree64(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HBITMAPUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + public static unsafe uint HDCUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + public static unsafe uint HDCUserSize64(this Windows thisApi, Span arg0, uint arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15523, Column 39 in objidl.h")] + public static unsafe uint HDCUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15524, Column 29 in objidl.h")] + public static unsafe byte* HDCUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, nint* arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15525, Column 29 in objidl.h")] + public static unsafe byte* HDCUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.HDCUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + public static unsafe void HDCUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.HDCUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + public static unsafe void HDCUserFree64(this Windows thisApi, Span arg0, nint* arg1) + { + // SpanOverloader + thisApi.HDCUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15526, Column 39 in objidl.h")] + public static unsafe void HDCUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.HDCUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15528, Column 39 in objidl.h")] + public static unsafe uint HICONUserSize64(this Windows thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15528, Column 39 in objidl.h")] + public static unsafe uint HICONUserSize64(this Windows thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15529, Column 29 in objidl.h")] + public static unsafe byte* HICONUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15530, Column 29 in objidl.h")] + public static unsafe byte* HICONUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15531, Column 39 in objidl.h")] + public static unsafe void HICONUserFree64(this Windows thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HICONUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15531, Column 39 in objidl.h")] + public static unsafe void HICONUserFree64(this Windows thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HICONUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15533, Column 39 in objidl.h")] + public static unsafe uint SNBUserSize64(this Windows thisApi, Span arg0, uint arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15533, Column 39 in objidl.h")] + public static unsafe uint SNBUserSize64(this Windows thisApi, Span arg0, uint arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, Span arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, Span arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15534, Column 29 in objidl.h")] + public static unsafe byte* SNBUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char*** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15535, Column 29 in objidl.h")] + public static unsafe byte* SNBUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char** arg2) + { + // SpanOverloader + return thisApi.SNBUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15536, Column 39 in objidl.h")] + public static unsafe void SNBUserFree64(this Windows thisApi, Span arg0, char*** arg1) + { + // SpanOverloader + thisApi.SNBUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15536, Column 39 in objidl.h")] + public static unsafe void SNBUserFree64(this Windows thisApi, Span arg0, ref char** arg1) + { + // SpanOverloader + thisApi.SNBUserFree64(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15538, Column 39 in objidl.h")] + public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15539, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 15540, Column 29 in objidl.h")] + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.STGMEDIUMUserFree64(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + { + // SpanOverloader + thisApi.STGMEDIUMUserFree64(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 15541, Column 39 in objidl.h")] + public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.STGMEDIUMUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxSetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS* pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxSetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15638, Column 41 in objidl.h")] + public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxSetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, IBindCtx* This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxSetBindOptionsStub(This, ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxSetBindOptionsStub(ref This.GetPinnableReference(), pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15644, Column 43 in objidl.h")] + public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, Span This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxSetBindOptionsStub(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxGetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS* pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxGetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15648, Column 41 in objidl.h")] + public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxGetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, IBindCtx* This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxGetBindOptionsStub(This, ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxGetBindOptionsStub(ref This.GetPinnableReference(), pbindopts); + } + + /// To be documented. + [NativeName("Src", "Line 15654, Column 43 in objidl.h")] + public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, Span This, Span pbindopts) + { + // SpanOverloader + return thisApi.IBindCtxGetBindOptionsStub(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public static unsafe int IEnumMonikerNextProxy(this Windows thisApi, IEnumMoniker* This, uint celt, IMoniker** rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public static unsafe int IEnumMonikerNextProxy(this Windows thisApi, IEnumMoniker* This, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextProxy(This, celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public static unsafe int IEnumMonikerNextProxy(this Windows thisApi, Span This, uint celt, IMoniker** rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public static unsafe int IEnumMonikerNextProxy(this Windows thisApi, Span This, uint celt, IMoniker** rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public static unsafe int IEnumMonikerNextProxy(this Windows thisApi, Span This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextProxy(ref This.GetPinnableReference(), celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15658, Column 41 in objidl.h")] + public static unsafe int IEnumMonikerNextProxy(this Windows thisApi, Span This, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextProxy(ref This.GetPinnableReference(), celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerNextStub(this Windows thisApi, IEnumMoniker* This, uint celt, IMoniker** rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerNextStub(this Windows thisApi, IEnumMoniker* This, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextStub(This, celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerNextStub(this Windows thisApi, Span This, uint celt, IMoniker** rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerNextStub(this Windows thisApi, Span This, uint celt, IMoniker** rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerNextStub(this Windows thisApi, Span This, uint celt, ref IMoniker* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextStub(ref This.GetPinnableReference(), celt, ref rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15667, Column 43 in objidl.h")] + public static unsafe int IEnumMonikerNextStub(this Windows thisApi, Span This, uint celt, ref IMoniker* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumMonikerNextStub(ref This.GetPinnableReference(), celt, ref rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15673, Column 38 in objidl.h")] + public static unsafe Silk.NET.Core.Bool32 IRunnableObjectIsRunningProxy(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IRunnableObjectIsRunningProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15677, Column 43 in objidl.h")] + public static unsafe int IRunnableObjectIsRunningStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IRunnableObjectIsRunningStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riidResult, void** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15680, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToObjectProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riidResult, ref void* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riidResult, ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riidResult, Silk.NET.Core.Native.IUnknown** ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15692, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToObjectStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riidResult, ref Silk.NET.Core.Native.IUnknown* ppvResult) + { + // SpanOverloader + return thisApi.IMonikerBindToObjectStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riidResult.GetPinnableReference(), ref ppvResult); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riid, void** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15699, Column 41 in objidl.h")] + public static unsafe int IMonikerBindToStorageProxy(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riid, ref void* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageProxy(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, IBindCtx* pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, IMoniker* This, Span pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(This, ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, IBindCtx* pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), pbc, ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, IMoniker* pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), pmkToLeft, ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Guid* riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), riid, ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riid, Silk.NET.Core.Native.IUnknown** ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15711, Column 43 in objidl.h")] + public static unsafe int IMonikerBindToStorageStub(this Windows thisApi, Span This, Span pbc, Span pmkToLeft, Span riid, ref Silk.NET.Core.Native.IUnknown* ppvObj) + { + // SpanOverloader + return thisApi.IMonikerBindToStorageStub(ref This.GetPinnableReference(), ref pbc.GetPinnableReference(), ref pmkToLeft.GetPinnableReference(), ref riid.GetPinnableReference(), ref ppvObj); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, IEnumSTATSTG* This, uint celt, STATSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, IEnumSTATSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, IEnumSTATSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, Span This, uint celt, STATSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, Span This, uint celt, STATSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15718, Column 41 in objidl.h")] + public static unsafe int IEnumSTATSTGNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, IEnumSTATSTG* This, uint celt, STATSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, IEnumSTATSTG* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, IEnumSTATSTG* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, Span This, uint celt, STATSTG* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, Span This, uint celt, STATSTG* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15727, Column 43 in objidl.h")] + public static unsafe int IEnumSTATSTGNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATSTGNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, in pwcsName.GetPinnableReference(), reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, in pwcsName.GetPinnableReference(), reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, in pwcsName.GetPinnableReference(), ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, in pwcsName.GetPinnableReference(), ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(This, pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, void* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15733, Column 41 in objidl.h")] + public static unsafe int IStorageOpenStreamProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageOpenStreamProxy(ref This.GetPinnableReference(), pwcsName, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, IStorage* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(This, pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), in pwcsName.GetPinnableReference(), cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, byte* reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, Span reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, ref reserved1.GetPinnableReference(), grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15745, Column 43 in objidl.h")] + public static unsafe int IStorageOpenStreamStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pwcsName, uint cbReserved1, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved1, uint grfMode, uint reserved2, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + // SpanOverloader + return thisApi.IStorageOpenStreamStub(ref This.GetPinnableReference(), pwcsName, cbReserved1, reserved1, grfMode, reserved2, ref ppstm); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(This, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(This, ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15754, Column 41 in objidl.h")] + public static unsafe int IStorageCopyToProxy(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToProxy(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(This, ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(This, ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(This, ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(This, ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(This, ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, IStorage* This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(This, ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, rgiidExclude, ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, char** snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, IStorage* pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, pstgDest); + } + + /// To be documented. + [NativeName("Src", "Line 15765, Column 43 in objidl.h")] + public static unsafe int IStorageCopyToStub(this Windows thisApi, Span This, uint ciidExclude, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan rgiidExclude, ref char* snbExclude, Span pstgDest) + { + // SpanOverloader + return thisApi.IStorageCopyToStub(ref This.GetPinnableReference(), ciidExclude, in rgiidExclude.GetPinnableReference(), ref snbExclude, ref pstgDest.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public static unsafe int IStorageEnumElementsProxy(this Windows thisApi, IStorage* This, uint reserved1, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageEnumElementsProxy(This, reserved1, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public static unsafe int IStorageEnumElementsProxy(this Windows thisApi, IStorage* This, uint reserved1, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageEnumElementsProxy(This, reserved1, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public static unsafe int IStorageEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, void* reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsProxy(ref This.GetPinnableReference(), reserved1, reserved2, reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public static unsafe int IStorageEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, void* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsProxy(ref This.GetPinnableReference(), reserved1, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public static unsafe int IStorageEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageEnumElementsProxy(ref This.GetPinnableReference(), reserved1, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15772, Column 41 in objidl.h")] + public static unsafe int IStorageEnumElementsProxy(this Windows thisApi, Span This, uint reserved1, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IStorageEnumElementsProxy(ref This.GetPinnableReference(), reserved1, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, IStorage* This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(This, reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, IStorage* This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(This, reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, byte* reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(ref This.GetPinnableReference(), reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, Span reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(ref This.GetPinnableReference(), reserved1, cbReserved2, ref reserved2.GetPinnableReference(), reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, IEnumSTATSTG** ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15784, Column 43 in objidl.h")] + public static unsafe int IStorageEnumElementsStub(this Windows thisApi, Span This, uint reserved1, uint cbReserved2, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string reserved2, uint reserved3, ref IEnumSTATSTG* ppenum) + { + // SpanOverloader + return thisApi.IStorageEnumElementsStub(ref This.GetPinnableReference(), reserved1, cbReserved2, reserved2, reserved3, ref ppenum); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, void* pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(This, ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, Span pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(This, ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, Span pv, uint cb, Span pcbRead) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(This, ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, void* pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, void* pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, Span pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(ref This.GetPinnableReference(), ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15792, Column 41 in objidl.h")] + public static unsafe int ILockBytesReadAtProxy(this Windows thisApi, Span This, ulong ulOffset, Span pv, uint cb, Span pcbRead) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesReadAtProxy(ref This.GetPinnableReference(), ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, byte* pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(This, ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, Span pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(This, ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, Span pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(This, ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(This, ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, Span This, ulong ulOffset, byte* pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, Span This, ulong ulOffset, byte* pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, Span This, ulong ulOffset, Span pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(ref This.GetPinnableReference(), ulOffset, ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, Span This, ulong ulOffset, Span pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(ref This.GetPinnableReference(), ulOffset, ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, Span This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbRead); + } + + /// To be documented. + [NativeName("Src", "Line 15802, Column 35 in objidl.h")] + public static unsafe int ILockBytesReadAtStub(this Windows thisApi, Span This, ulong ulOffset, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbRead) + { + // SpanOverloader + return thisApi.ILockBytesReadAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15809, Column 41 in objidl.h")] + public static unsafe int ILockBytesWriteAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.ILockBytesWriteAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(This, ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(This, ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, ILockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 15819, Column 43 in objidl.h")] + public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.ILockBytesWriteAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15826, Column 41 in objidl.h")] + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15835, Column 43 in objidl.h")] + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15841, Column 41 in objidl.h")] + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + [NativeName("Src", "Line 15850, Column 43 in objidl.h")] + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + { + // SpanOverloader + return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15856, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(This, pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15864, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15869, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnViewChangeProxy(this Windows thisApi, Span This, uint dwAspect, int lindex) + { + // SpanOverloader + thisApi.IAdviseSinkOnViewChangeProxy(ref This.GetPinnableReference(), dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15875, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnViewChangeStub(this Windows thisApi, Span This, uint dwAspect, int lindex) + { + // SpanOverloader + return thisApi.IAdviseSinkOnViewChangeStub(ref This.GetPinnableReference(), dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnRenameProxy(this Windows thisApi, IAdviseSink* This, Span pmk) + { + // SpanOverloader + thisApi.IAdviseSinkOnRenameProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnRenameProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + thisApi.IAdviseSinkOnRenameProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15880, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnRenameProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + thisApi.IAdviseSinkOnRenameProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnRenameStub(this Windows thisApi, IAdviseSink* This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSinkOnRenameStub(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnRenameStub(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.IAdviseSinkOnRenameStub(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15886, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnRenameStub(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSinkOnRenameStub(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15890, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnSaveProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.IAdviseSinkOnSaveProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15894, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnSaveStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IAdviseSinkOnSaveStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15897, Column 38 in objidl.h")] + public static unsafe void IAdviseSinkOnCloseProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.IAdviseSinkOnCloseProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15901, Column 43 in objidl.h")] + public static unsafe int IAdviseSinkOnCloseStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.IAdviseSinkOnCloseStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15904, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(This, pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); + } + + /// To be documented. + [NativeName("Src", "Line 15912, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15917, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishOnDataChangeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishOnDataChangeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15921, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishOnDataChangeStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishOnDataChangeStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15924, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnViewChangeProxy(this Windows thisApi, Span This, uint dwAspect, int lindex) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnViewChangeProxy(ref This.GetPinnableReference(), dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15930, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnViewChangeStub(this Windows thisApi, Span This, uint dwAspect, int lindex) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnViewChangeStub(ref This.GetPinnableReference(), dwAspect, lindex); + } + + /// To be documented. + [NativeName("Src", "Line 15935, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishOnViewChangeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishOnViewChangeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15939, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishOnViewChangeStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishOnViewChangeStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnRenameProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pmk) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnRenameProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnRenameProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnRenameProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15942, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnRenameProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnRenameProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnRenameStub(this Windows thisApi, AsyncIAdviseSink* This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnRenameStub(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnRenameStub(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnRenameStub(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15948, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnRenameStub(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnRenameStub(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15952, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishOnRenameProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishOnRenameProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15956, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishOnRenameStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishOnRenameStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15959, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnSaveProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnSaveProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15963, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnSaveStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnSaveStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15966, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishOnSaveProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishOnSaveProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15970, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishOnSaveStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishOnSaveStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15973, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkBeginOnCloseProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkBeginOnCloseProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15977, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkBeginOnCloseStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkBeginOnCloseStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15980, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSinkFinishOnCloseProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSinkFinishOnCloseProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15984, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSinkFinishOnCloseStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSinkFinishOnCloseStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public static unsafe void IAdviseSink2OnLinkSrcChangeProxy(this Windows thisApi, IAdviseSink2* This, Span pmk) + { + // SpanOverloader + thisApi.IAdviseSink2OnLinkSrcChangeProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public static unsafe void IAdviseSink2OnLinkSrcChangeProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + thisApi.IAdviseSink2OnLinkSrcChangeProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15987, Column 38 in objidl.h")] + public static unsafe void IAdviseSink2OnLinkSrcChangeProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + thisApi.IAdviseSink2OnLinkSrcChangeProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public static unsafe int IAdviseSink2OnLinkSrcChangeStub(this Windows thisApi, IAdviseSink2* This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSink2OnLinkSrcChangeStub(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public static unsafe int IAdviseSink2OnLinkSrcChangeStub(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.IAdviseSink2OnLinkSrcChangeStub(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15993, Column 43 in objidl.h")] + public static unsafe int IAdviseSink2OnLinkSrcChangeStub(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.IAdviseSink2OnLinkSrcChangeStub(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(this Windows thisApi, AsyncIAdviseSink2* This, Span pmk) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 15997, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2BeginOnLinkSrcChangeProxy(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(this Windows thisApi, AsyncIAdviseSink2* This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2BeginOnLinkSrcChangeStub(This, ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(this Windows thisApi, Span This, IMoniker* pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref This.GetPinnableReference(), pmk); + } + + /// To be documented. + [NativeName("Src", "Line 16003, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2BeginOnLinkSrcChangeStub(this Windows thisApi, Span This, Span pmk) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2BeginOnLinkSrcChangeStub(ref This.GetPinnableReference(), ref pmk.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16007, Column 38 in objidl.h")] + public static unsafe void AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(this Windows thisApi, Span This) + { + // SpanOverloader + thisApi.AsyncIAdviseSink2FinishOnLinkSrcChangeProxy(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16011, Column 43 in objidl.h")] + public static unsafe int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(this Windows thisApi, Span This) + { + // SpanOverloader + return thisApi.AsyncIAdviseSink2FinishOnLinkSrcChangeStub(ref This.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetcIn, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(This, pformatetcIn, ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, TagSTGMEDIUM* pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, TagSTGMEDIUM* pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16014, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(This, pformatetcIn, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(This, ref pformatetcIn.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(This, ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), pformatetcIn, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), pformatetcIn, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16022, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, Span pformatetcIn, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(This, pformatetc, ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium); + } + + /// To be documented. + [NativeName("Src", "Line 16027, Column 41 in objidl.h")] + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(This, pformatetc, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(This, ref pformatetc.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, Span pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(This, ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), pformatetc, pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), pformatetc, ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pRemoteMedium); + } + + /// To be documented. + [NativeName("Src", "Line 16035, Column 43 in objidl.h")] + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, Span pformatetc, Span pRemoteMedium) + { + // SpanOverloader + return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(This, pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(This, ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16040, Column 41 in objidl.h")] + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(This, pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(This, ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), pformatetc, pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium, fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16049, Column 43 in objidl.h")] + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + { + // SpanOverloader + return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(This, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(This, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(This, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(ref This.GetPinnableReference(), pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(ref This.GetPinnableReference(), pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(ref This.GetPinnableReference(), in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16055, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendProxy(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendProxy(ref This.GetPinnableReference(), in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(This, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(This, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(This, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, IFillLockBytes* This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(This, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(ref This.GetPinnableReference(), pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(ref This.GetPinnableReference(), pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(ref This.GetPinnableReference(), in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(ref This.GetPinnableReference(), in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(ref This.GetPinnableReference(), pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16065, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAppendStub(this Windows thisApi, Span This, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAppendStub(ref This.GetPinnableReference(), pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(This, ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16071, Column 41 in objidl.h")] + public static unsafe int IFillLockBytesFillAtProxy(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtProxy(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(This, ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(This, ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, IFillLockBytes* This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(This, ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(ref This.GetPinnableReference(), ulOffset, in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, uint* pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, pcbWritten); + } + + /// To be documented. + [NativeName("Src", "Line 16083, Column 35 in objidl.h")] + public static unsafe int IFillLockBytesFillAtStub(this Windows thisApi, Span This, ulong ulOffset, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pv, uint cb, Span pcbWritten) + { + // SpanOverloader + return thisApi.IFillLockBytesFillAtStub(ref This.GetPinnableReference(), ulOffset, pv, cb, ref pcbWritten.GetPinnableReference()); + } + /// To be documented. [NativeName("Src", "Line 541, Column 1 in evntprov.h")] public static unsafe uint EventRegister(this Windows thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* ProviderId, PfnPenablecallback EnableCallback, void* CallbackContext, Span RegHandle) diff --git a/src/Core/Silk.NET.Core/win32extras.h b/src/Core/Silk.NET.Core/win32extras.h index 3442a568df..70a5292577 100644 --- a/src/Core/Silk.NET.Core/win32extras.h +++ b/src/Core/Silk.NET.Core/win32extras.h @@ -10,3 +10,4 @@ #include #include #include +#include diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs new file mode 100644 index 0000000000..4e3eef1fb1 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WIC8BIMIptcDigestProperties")] + public enum WIC8BIMIptcDigestProperties : int + { + [Obsolete("Deprecated in favour of \"PString\"")] + [NativeName("Name", "WIC8BIMIptcDigestPString")] + Wic8BimiptcDigestPString = 0x1, + [Obsolete("Deprecated in favour of \"IptcDigest\"")] + [NativeName("Name", "WIC8BIMIptcDigestIptcDigest")] + Wic8BimiptcDigestIptcDigest = 0x2, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WIC8BIMIptcDigestProperties_FORCE_DWORD")] + Wic8BimiptcDigestPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WIC8BIMIptcDigestPString")] + PString = 0x1, + [NativeName("Name", "WIC8BIMIptcDigestIptcDigest")] + IptcDigest = 0x2, + [NativeName("Name", "WIC8BIMIptcDigestProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs new file mode 100644 index 0000000000..98fbabe6ed --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WIC8BIMIptcProperties")] + public enum WIC8BIMIptcProperties : int + { + [Obsolete("Deprecated in favour of \"PString\"")] + [NativeName("Name", "WIC8BIMIptcPString")] + Wic8BimiptcPString = 0x0, + [Obsolete("Deprecated in favour of \"EmbeddedIptc\"")] + [NativeName("Name", "WIC8BIMIptcEmbeddedIPTC")] + Wic8BimiptcEmbeddedIptc = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WIC8BIMIptcProperties_FORCE_DWORD")] + Wic8BimiptcPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WIC8BIMIptcPString")] + PString = 0x0, + [NativeName("Name", "WIC8BIMIptcEmbeddedIPTC")] + EmbeddedIptc = 0x1, + [NativeName("Name", "WIC8BIMIptcProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs new file mode 100644 index 0000000000..f6ec50e724 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WIC8BIMResolutionInfoProperties")] + public enum WIC8BIMResolutionInfoProperties : int + { + [Obsolete("Deprecated in favour of \"PString\"")] + [NativeName("Name", "WIC8BIMResolutionInfoPString")] + Wic8BimresolutionInfoPString = 0x1, + [Obsolete("Deprecated in favour of \"HResolution\"")] + [NativeName("Name", "WIC8BIMResolutionInfoHResolution")] + Wic8BimresolutionInfoHResolution = 0x2, + [Obsolete("Deprecated in favour of \"HResolutionUnit\"")] + [NativeName("Name", "WIC8BIMResolutionInfoHResolutionUnit")] + Wic8BimresolutionInfoHResolutionUnit = 0x3, + [Obsolete("Deprecated in favour of \"WidthUnit\"")] + [NativeName("Name", "WIC8BIMResolutionInfoWidthUnit")] + Wic8BimresolutionInfoWidthUnit = 0x4, + [Obsolete("Deprecated in favour of \"VResolution\"")] + [NativeName("Name", "WIC8BIMResolutionInfoVResolution")] + Wic8BimresolutionInfoVResolution = 0x5, + [Obsolete("Deprecated in favour of \"VResolutionUnit\"")] + [NativeName("Name", "WIC8BIMResolutionInfoVResolutionUnit")] + Wic8BimresolutionInfoVResolutionUnit = 0x6, + [Obsolete("Deprecated in favour of \"HeightUnit\"")] + [NativeName("Name", "WIC8BIMResolutionInfoHeightUnit")] + Wic8BimresolutionInfoHeightUnit = 0x7, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WIC8BIMResolutionInfoProperties_FORCE_DWORD")] + Wic8BimresolutionInfoPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WIC8BIMResolutionInfoPString")] + PString = 0x1, + [NativeName("Name", "WIC8BIMResolutionInfoHResolution")] + HResolution = 0x2, + [NativeName("Name", "WIC8BIMResolutionInfoHResolutionUnit")] + HResolutionUnit = 0x3, + [NativeName("Name", "WIC8BIMResolutionInfoWidthUnit")] + WidthUnit = 0x4, + [NativeName("Name", "WIC8BIMResolutionInfoVResolution")] + VResolution = 0x5, + [NativeName("Name", "WIC8BIMResolutionInfoVResolutionUnit")] + VResolutionUnit = 0x6, + [NativeName("Name", "WIC8BIMResolutionInfoHeightUnit")] + HeightUnit = 0x7, + [NativeName("Name", "WIC8BIMResolutionInfoProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs new file mode 100644 index 0000000000..873630f200 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapAlphaChannelOption")] + public enum WICBitmapAlphaChannelOption : int + { + [Obsolete("Deprecated in favour of \"BitmapUseAlpha\"")] + [NativeName("Name", "WICBitmapUseAlpha")] + WicbitmapUseAlpha = 0x0, + [Obsolete("Deprecated in favour of \"BitmapUsePremultipliedAlpha\"")] + [NativeName("Name", "WICBitmapUsePremultipliedAlpha")] + WicbitmapUsePremultipliedAlpha = 0x1, + [Obsolete("Deprecated in favour of \"BitmapIgnoreAlpha\"")] + [NativeName("Name", "WICBitmapIgnoreAlpha")] + WicbitmapIgnoreAlpha = 0x2, + [Obsolete("Deprecated in favour of \"ItmapalphachanneloptionsForceDword\"")] + [NativeName("Name", "WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD")] + WicbitmapalphachanneloptionsForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapUseAlpha")] + BitmapUseAlpha = 0x0, + [NativeName("Name", "WICBitmapUsePremultipliedAlpha")] + BitmapUsePremultipliedAlpha = 0x1, + [NativeName("Name", "WICBitmapIgnoreAlpha")] + BitmapIgnoreAlpha = 0x2, + [NativeName("Name", "WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD")] + ItmapalphachanneloptionsForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs new file mode 100644 index 0000000000..d18dbe9d8c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapCreateCacheOption")] + public enum WICBitmapCreateCacheOption : int + { + [Obsolete("Deprecated in favour of \"BitmapNoCache\"")] + [NativeName("Name", "WICBitmapNoCache")] + WicbitmapNoCache = 0x0, + [Obsolete("Deprecated in favour of \"BitmapCacheOnDemand\"")] + [NativeName("Name", "WICBitmapCacheOnDemand")] + WicbitmapCacheOnDemand = 0x1, + [Obsolete("Deprecated in favour of \"BitmapCacheOnLoad\"")] + [NativeName("Name", "WICBitmapCacheOnLoad")] + WicbitmapCacheOnLoad = 0x2, + [Obsolete("Deprecated in favour of \"ItmapcreatecacheoptionForceDword\"")] + [NativeName("Name", "WICBITMAPCREATECACHEOPTION_FORCE_DWORD")] + WicbitmapcreatecacheoptionForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapNoCache")] + BitmapNoCache = 0x0, + [NativeName("Name", "WICBitmapCacheOnDemand")] + BitmapCacheOnDemand = 0x1, + [NativeName("Name", "WICBitmapCacheOnLoad")] + BitmapCacheOnLoad = 0x2, + [NativeName("Name", "WICBITMAPCREATECACHEOPTION_FORCE_DWORD")] + ItmapcreatecacheoptionForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs new file mode 100644 index 0000000000..264b85f991 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs @@ -0,0 +1,49 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICBitmapDecoderCapabilities")] + public enum WICBitmapDecoderCapabilities : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilitySameEncoder\"")] + [NativeName("Name", "WICBitmapDecoderCapabilitySameEncoder")] + WicbitmapDecoderCapabilitySameEncoder = 0x1, + [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanDecodeAllImages\"")] + [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeAllImages")] + WicbitmapDecoderCapabilityCanDecodeAllImages = 0x2, + [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanDecodeSomeImages\"")] + [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeSomeImages")] + WicbitmapDecoderCapabilityCanDecodeSomeImages = 0x4, + [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanEnumerateMetadata\"")] + [NativeName("Name", "WICBitmapDecoderCapabilityCanEnumerateMetadata")] + WicbitmapDecoderCapabilityCanEnumerateMetadata = 0x8, + [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanDecodeThumbnail\"")] + [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeThumbnail")] + WicbitmapDecoderCapabilityCanDecodeThumbnail = 0x10, + [Obsolete("Deprecated in favour of \"ItmapdecodercapabilitiesForceDword\"")] + [NativeName("Name", "WICBITMAPDECODERCAPABILITIES_FORCE_DWORD")] + WicbitmapdecodercapabilitiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapDecoderCapabilitySameEncoder")] + BitmapDecoderCapabilitySameEncoder = 0x1, + [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeAllImages")] + BitmapDecoderCapabilityCanDecodeAllImages = 0x2, + [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeSomeImages")] + BitmapDecoderCapabilityCanDecodeSomeImages = 0x4, + [NativeName("Name", "WICBitmapDecoderCapabilityCanEnumerateMetadata")] + BitmapDecoderCapabilityCanEnumerateMetadata = 0x8, + [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeThumbnail")] + BitmapDecoderCapabilityCanDecodeThumbnail = 0x10, + [NativeName("Name", "WICBITMAPDECODERCAPABILITIES_FORCE_DWORD")] + ItmapdecodercapabilitiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs new file mode 100644 index 0000000000..e26a80a463 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs @@ -0,0 +1,71 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapDitherType")] + public enum WICBitmapDitherType : int + { + [Obsolete("Deprecated in favour of \"BitmapDitherTypeNone\"")] + [NativeName("Name", "WICBitmapDitherTypeNone")] + WicbitmapDitherTypeNone = 0x0, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeSolid\"")] + [NativeName("Name", "WICBitmapDitherTypeSolid")] + WicbitmapDitherTypeSolid = 0x0, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeOrdered4x4\"")] + [NativeName("Name", "WICBitmapDitherTypeOrdered4x4")] + WicbitmapDitherTypeOrdered4x4 = 0x1, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeOrdered8x8\"")] + [NativeName("Name", "WICBitmapDitherTypeOrdered8x8")] + WicbitmapDitherTypeOrdered8x8 = 0x2, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeOrdered16x16\"")] + [NativeName("Name", "WICBitmapDitherTypeOrdered16x16")] + WicbitmapDitherTypeOrdered16x16 = 0x3, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeSpiral4x4\"")] + [NativeName("Name", "WICBitmapDitherTypeSpiral4x4")] + WicbitmapDitherTypeSpiral4x4 = 0x4, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeSpiral8x8\"")] + [NativeName("Name", "WICBitmapDitherTypeSpiral8x8")] + WicbitmapDitherTypeSpiral8x8 = 0x5, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeDualSpiral4x4\"")] + [NativeName("Name", "WICBitmapDitherTypeDualSpiral4x4")] + WicbitmapDitherTypeDualSpiral4x4 = 0x6, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeDualSpiral8x8\"")] + [NativeName("Name", "WICBitmapDitherTypeDualSpiral8x8")] + WicbitmapDitherTypeDualSpiral8x8 = 0x7, + [Obsolete("Deprecated in favour of \"BitmapDitherTypeErrorDiffusion\"")] + [NativeName("Name", "WICBitmapDitherTypeErrorDiffusion")] + WicbitmapDitherTypeErrorDiffusion = 0x8, + [Obsolete("Deprecated in favour of \"ItmapdithertypeForceDword\"")] + [NativeName("Name", "WICBITMAPDITHERTYPE_FORCE_DWORD")] + WicbitmapdithertypeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapDitherTypeNone")] + BitmapDitherTypeNone = 0x0, + [NativeName("Name", "WICBitmapDitherTypeSolid")] + BitmapDitherTypeSolid = 0x0, + [NativeName("Name", "WICBitmapDitherTypeOrdered4x4")] + BitmapDitherTypeOrdered4x4 = 0x1, + [NativeName("Name", "WICBitmapDitherTypeOrdered8x8")] + BitmapDitherTypeOrdered8x8 = 0x2, + [NativeName("Name", "WICBitmapDitherTypeOrdered16x16")] + BitmapDitherTypeOrdered16x16 = 0x3, + [NativeName("Name", "WICBitmapDitherTypeSpiral4x4")] + BitmapDitherTypeSpiral4x4 = 0x4, + [NativeName("Name", "WICBitmapDitherTypeSpiral8x8")] + BitmapDitherTypeSpiral8x8 = 0x5, + [NativeName("Name", "WICBitmapDitherTypeDualSpiral4x4")] + BitmapDitherTypeDualSpiral4x4 = 0x6, + [NativeName("Name", "WICBitmapDitherTypeDualSpiral8x8")] + BitmapDitherTypeDualSpiral8x8 = 0x7, + [NativeName("Name", "WICBitmapDitherTypeErrorDiffusion")] + BitmapDitherTypeErrorDiffusion = 0x8, + [NativeName("Name", "WICBITMAPDITHERTYPE_FORCE_DWORD")] + ItmapdithertypeForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs new file mode 100644 index 0000000000..f50c33f58e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapEncoderCacheOption")] + public enum WICBitmapEncoderCacheOption : int + { + [Obsolete("Deprecated in favour of \"BitmapEncoderCacheInMemory\"")] + [NativeName("Name", "WICBitmapEncoderCacheInMemory")] + WicbitmapEncoderCacheInMemory = 0x0, + [Obsolete("Deprecated in favour of \"BitmapEncoderCacheTempFile\"")] + [NativeName("Name", "WICBitmapEncoderCacheTempFile")] + WicbitmapEncoderCacheTempFile = 0x1, + [Obsolete("Deprecated in favour of \"BitmapEncoderNoCache\"")] + [NativeName("Name", "WICBitmapEncoderNoCache")] + WicbitmapEncoderNoCache = 0x2, + [Obsolete("Deprecated in favour of \"ItmapencodercacheoptionForceDword\"")] + [NativeName("Name", "WICBITMAPENCODERCACHEOPTION_FORCE_DWORD")] + WicbitmapencodercacheoptionForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapEncoderCacheInMemory")] + BitmapEncoderCacheInMemory = 0x0, + [NativeName("Name", "WICBitmapEncoderCacheTempFile")] + BitmapEncoderCacheTempFile = 0x1, + [NativeName("Name", "WICBitmapEncoderNoCache")] + BitmapEncoderNoCache = 0x2, + [NativeName("Name", "WICBITMAPENCODERCACHEOPTION_FORCE_DWORD")] + ItmapencodercacheoptionForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs new file mode 100644 index 0000000000..ade8cbad1e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapInterpolationMode")] + public enum WICBitmapInterpolationMode : int + { + [Obsolete("Deprecated in favour of \"BitmapInterpolationModeNearestNeighbor\"")] + [NativeName("Name", "WICBitmapInterpolationModeNearestNeighbor")] + WicbitmapInterpolationModeNearestNeighbor = 0x0, + [Obsolete("Deprecated in favour of \"BitmapInterpolationModeLinear\"")] + [NativeName("Name", "WICBitmapInterpolationModeLinear")] + WicbitmapInterpolationModeLinear = 0x1, + [Obsolete("Deprecated in favour of \"BitmapInterpolationModeCubic\"")] + [NativeName("Name", "WICBitmapInterpolationModeCubic")] + WicbitmapInterpolationModeCubic = 0x2, + [Obsolete("Deprecated in favour of \"BitmapInterpolationModeFant\"")] + [NativeName("Name", "WICBitmapInterpolationModeFant")] + WicbitmapInterpolationModeFant = 0x3, + [Obsolete("Deprecated in favour of \"BitmapInterpolationModeHighQualityCubic\"")] + [NativeName("Name", "WICBitmapInterpolationModeHighQualityCubic")] + WicbitmapInterpolationModeHighQualityCubic = 0x4, + [Obsolete("Deprecated in favour of \"ItmapinterpolationmodeForceDword\"")] + [NativeName("Name", "WICBITMAPINTERPOLATIONMODE_FORCE_DWORD")] + WicbitmapinterpolationmodeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapInterpolationModeNearestNeighbor")] + BitmapInterpolationModeNearestNeighbor = 0x0, + [NativeName("Name", "WICBitmapInterpolationModeLinear")] + BitmapInterpolationModeLinear = 0x1, + [NativeName("Name", "WICBitmapInterpolationModeCubic")] + BitmapInterpolationModeCubic = 0x2, + [NativeName("Name", "WICBitmapInterpolationModeFant")] + BitmapInterpolationModeFant = 0x3, + [NativeName("Name", "WICBitmapInterpolationModeHighQualityCubic")] + BitmapInterpolationModeHighQualityCubic = 0x4, + [NativeName("Name", "WICBITMAPINTERPOLATIONMODE_FORCE_DWORD")] + ItmapinterpolationmodeForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs new file mode 100644 index 0000000000..955d0c2c1c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapLockFlags")] + public enum WICBitmapLockFlags : int + { + [Obsolete("Deprecated in favour of \"BitmapLockRead\"")] + [NativeName("Name", "WICBitmapLockRead")] + WicbitmapLockRead = 0x1, + [Obsolete("Deprecated in favour of \"BitmapLockWrite\"")] + [NativeName("Name", "WICBitmapLockWrite")] + WicbitmapLockWrite = 0x2, + [Obsolete("Deprecated in favour of \"ItmaplockflagsForceDword\"")] + [NativeName("Name", "WICBITMAPLOCKFLAGS_FORCE_DWORD")] + WicbitmaplockflagsForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapLockRead")] + BitmapLockRead = 0x1, + [NativeName("Name", "WICBitmapLockWrite")] + BitmapLockWrite = 0x2, + [NativeName("Name", "WICBITMAPLOCKFLAGS_FORCE_DWORD")] + ItmaplockflagsForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs new file mode 100644 index 0000000000..ee3e9c1ef6 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs @@ -0,0 +1,91 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapPaletteType")] + public enum WICBitmapPaletteType : int + { + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeCustom\"")] + [NativeName("Name", "WICBitmapPaletteTypeCustom")] + WicbitmapPaletteTypeCustom = 0x0, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeMedianCut\"")] + [NativeName("Name", "WICBitmapPaletteTypeMedianCut")] + WicbitmapPaletteTypeMedianCut = 0x1, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedBW\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedBW")] + WicbitmapPaletteTypeFixedBW = 0x2, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone8\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone8")] + WicbitmapPaletteTypeFixedHalftone8 = 0x3, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone27\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone27")] + WicbitmapPaletteTypeFixedHalftone27 = 0x4, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone64\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone64")] + WicbitmapPaletteTypeFixedHalftone64 = 0x5, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone125\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone125")] + WicbitmapPaletteTypeFixedHalftone125 = 0x6, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone216\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone216")] + WicbitmapPaletteTypeFixedHalftone216 = 0x7, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedWebPalette\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedWebPalette")] + WicbitmapPaletteTypeFixedWebPalette = 0x7, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone252\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone252")] + WicbitmapPaletteTypeFixedHalftone252 = 0x8, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone256\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone256")] + WicbitmapPaletteTypeFixedHalftone256 = 0x9, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedGray4\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedGray4")] + WicbitmapPaletteTypeFixedGray4 = 0xA, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedGray16\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedGray16")] + WicbitmapPaletteTypeFixedGray16 = 0xB, + [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedGray256\"")] + [NativeName("Name", "WICBitmapPaletteTypeFixedGray256")] + WicbitmapPaletteTypeFixedGray256 = 0xC, + [Obsolete("Deprecated in favour of \"ItmappalettetypeForceDword\"")] + [NativeName("Name", "WICBITMAPPALETTETYPE_FORCE_DWORD")] + WicbitmappalettetypeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapPaletteTypeCustom")] + BitmapPaletteTypeCustom = 0x0, + [NativeName("Name", "WICBitmapPaletteTypeMedianCut")] + BitmapPaletteTypeMedianCut = 0x1, + [NativeName("Name", "WICBitmapPaletteTypeFixedBW")] + BitmapPaletteTypeFixedBW = 0x2, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone8")] + BitmapPaletteTypeFixedHalftone8 = 0x3, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone27")] + BitmapPaletteTypeFixedHalftone27 = 0x4, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone64")] + BitmapPaletteTypeFixedHalftone64 = 0x5, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone125")] + BitmapPaletteTypeFixedHalftone125 = 0x6, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone216")] + BitmapPaletteTypeFixedHalftone216 = 0x7, + [NativeName("Name", "WICBitmapPaletteTypeFixedWebPalette")] + BitmapPaletteTypeFixedWebPalette = 0x7, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone252")] + BitmapPaletteTypeFixedHalftone252 = 0x8, + [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone256")] + BitmapPaletteTypeFixedHalftone256 = 0x9, + [NativeName("Name", "WICBitmapPaletteTypeFixedGray4")] + BitmapPaletteTypeFixedGray4 = 0xA, + [NativeName("Name", "WICBitmapPaletteTypeFixedGray16")] + BitmapPaletteTypeFixedGray16 = 0xB, + [NativeName("Name", "WICBitmapPaletteTypeFixedGray256")] + BitmapPaletteTypeFixedGray256 = 0xC, + [NativeName("Name", "WICBITMAPPALETTETYPE_FORCE_DWORD")] + ItmappalettetypeForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs new file mode 100644 index 0000000000..70c5800c28 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs @@ -0,0 +1,52 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICBitmapTransformOptions")] + public enum WICBitmapTransformOptions : int + { + [Obsolete("Deprecated in favour of \"BitmapTransformRotate0\"")] + [NativeName("Name", "WICBitmapTransformRotate0")] + WicbitmapTransformRotate0 = 0x0, + [Obsolete("Deprecated in favour of \"BitmapTransformRotate90\"")] + [NativeName("Name", "WICBitmapTransformRotate90")] + WicbitmapTransformRotate90 = 0x1, + [Obsolete("Deprecated in favour of \"BitmapTransformRotate180\"")] + [NativeName("Name", "WICBitmapTransformRotate180")] + WicbitmapTransformRotate180 = 0x2, + [Obsolete("Deprecated in favour of \"BitmapTransformRotate270\"")] + [NativeName("Name", "WICBitmapTransformRotate270")] + WicbitmapTransformRotate270 = 0x3, + [Obsolete("Deprecated in favour of \"BitmapTransformFlipHorizontal\"")] + [NativeName("Name", "WICBitmapTransformFlipHorizontal")] + WicbitmapTransformFlipHorizontal = 0x8, + [Obsolete("Deprecated in favour of \"BitmapTransformFlipVertical\"")] + [NativeName("Name", "WICBitmapTransformFlipVertical")] + WicbitmapTransformFlipVertical = 0x10, + [Obsolete("Deprecated in favour of \"ItmaptransformoptionsForceDword\"")] + [NativeName("Name", "WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD")] + WicbitmaptransformoptionsForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICBitmapTransformRotate0")] + BitmapTransformRotate0 = 0x0, + [NativeName("Name", "WICBitmapTransformRotate90")] + BitmapTransformRotate90 = 0x1, + [NativeName("Name", "WICBitmapTransformRotate180")] + BitmapTransformRotate180 = 0x2, + [NativeName("Name", "WICBitmapTransformRotate270")] + BitmapTransformRotate270 = 0x3, + [NativeName("Name", "WICBitmapTransformFlipHorizontal")] + BitmapTransformFlipHorizontal = 0x8, + [NativeName("Name", "WICBitmapTransformFlipVertical")] + BitmapTransformFlipVertical = 0x10, + [NativeName("Name", "WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD")] + ItmaptransformoptionsForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs new file mode 100644 index 0000000000..fd9d012f6e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICColorContextType")] + public enum WICColorContextType : int + { + [Obsolete("Deprecated in favour of \"Uninitialized\"")] + [NativeName("Name", "WICColorContextUninitialized")] + WiccolorContextUninitialized = 0x0, + [Obsolete("Deprecated in favour of \"Profile\"")] + [NativeName("Name", "WICColorContextProfile")] + WiccolorContextProfile = 0x1, + [Obsolete("Deprecated in favour of \"ExifColorSpace\"")] + [NativeName("Name", "WICColorContextExifColorSpace")] + WiccolorContextExifColorSpace = 0x2, + [NativeName("Name", "WICColorContextUninitialized")] + Uninitialized = 0x0, + [NativeName("Name", "WICColorContextProfile")] + Profile = 0x1, + [NativeName("Name", "WICColorContextExifColorSpace")] + ExifColorSpace = 0x2, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs new file mode 100644 index 0000000000..2e32a37820 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs @@ -0,0 +1,47 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICComponentEnumerateOptions")] + public enum WICComponentEnumerateOptions : int + { + [Obsolete("Deprecated in favour of \"ComponentEnumerateDefault\"")] + [NativeName("Name", "WICComponentEnumerateDefault")] + WiccomponentEnumerateDefault = 0x0, + [Obsolete("Deprecated in favour of \"ComponentEnumerateRefresh\"")] + [NativeName("Name", "WICComponentEnumerateRefresh")] + WiccomponentEnumerateRefresh = 0x1, + [Obsolete("Deprecated in favour of \"ComponentEnumerateDisabled\"")] + [NativeName("Name", "WICComponentEnumerateDisabled")] + WiccomponentEnumerateDisabled = unchecked((int) 0xFFFFFFFF80000000), + [Obsolete("Deprecated in favour of \"ComponentEnumerateUnsigned\"")] + [NativeName("Name", "WICComponentEnumerateUnsigned")] + WiccomponentEnumerateUnsigned = 0x40000000, + [Obsolete("Deprecated in favour of \"ComponentEnumerateBuiltInOnly\"")] + [NativeName("Name", "WICComponentEnumerateBuiltInOnly")] + WiccomponentEnumerateBuiltInOnly = 0x20000000, + [Obsolete("Deprecated in favour of \"OmponentenumerateoptionsForceDword\"")] + [NativeName("Name", "WICCOMPONENTENUMERATEOPTIONS_FORCE_DWORD")] + WiccomponentenumerateoptionsForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICComponentEnumerateDefault")] + ComponentEnumerateDefault = 0x0, + [NativeName("Name", "WICComponentEnumerateRefresh")] + ComponentEnumerateRefresh = 0x1, + [NativeName("Name", "WICComponentEnumerateDisabled")] + ComponentEnumerateDisabled = unchecked((int) 0xFFFFFFFF80000000), + [NativeName("Name", "WICComponentEnumerateUnsigned")] + ComponentEnumerateUnsigned = 0x40000000, + [NativeName("Name", "WICComponentEnumerateBuiltInOnly")] + ComponentEnumerateBuiltInOnly = 0x20000000, + [NativeName("Name", "WICCOMPONENTENUMERATEOPTIONS_FORCE_DWORD")] + OmponentenumerateoptionsForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs new file mode 100644 index 0000000000..22447158fc --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICComponentSigning")] + public enum WICComponentSigning : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"ComponentSigned\"")] + [NativeName("Name", "WICComponentSigned")] + WiccomponentSigned = 0x1, + [Obsolete("Deprecated in favour of \"ComponentUnsigned\"")] + [NativeName("Name", "WICComponentUnsigned")] + WiccomponentUnsigned = 0x2, + [Obsolete("Deprecated in favour of \"ComponentSafe\"")] + [NativeName("Name", "WICComponentSafe")] + WiccomponentSafe = 0x4, + [Obsolete("Deprecated in favour of \"ComponentDisabled\"")] + [NativeName("Name", "WICComponentDisabled")] + WiccomponentDisabled = unchecked((int) 0xFFFFFFFF80000000), + [Obsolete("Deprecated in favour of \"OmponentsigningForceDword\"")] + [NativeName("Name", "WICCOMPONENTSIGNING_FORCE_DWORD")] + WiccomponentsigningForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICComponentSigned")] + ComponentSigned = 0x1, + [NativeName("Name", "WICComponentUnsigned")] + ComponentUnsigned = 0x2, + [NativeName("Name", "WICComponentSafe")] + ComponentSafe = 0x4, + [NativeName("Name", "WICComponentDisabled")] + ComponentDisabled = unchecked((int) 0xFFFFFFFF80000000), + [NativeName("Name", "WICCOMPONENTSIGNING_FORCE_DWORD")] + OmponentsigningForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs new file mode 100644 index 0000000000..681a231711 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs @@ -0,0 +1,59 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICComponentType")] + public enum WICComponentType : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Decoder\"")] + [NativeName("Name", "WICDecoder")] + Wicdecoder = 0x1, + [Obsolete("Deprecated in favour of \"Encoder\"")] + [NativeName("Name", "WICEncoder")] + Wicencoder = 0x2, + [Obsolete("Deprecated in favour of \"PixelFormatConverter\"")] + [NativeName("Name", "WICPixelFormatConverter")] + WicpixelFormatConverter = 0x4, + [Obsolete("Deprecated in favour of \"MetadataReader\"")] + [NativeName("Name", "WICMetadataReader")] + WicmetadataReader = 0x8, + [Obsolete("Deprecated in favour of \"MetadataWriter\"")] + [NativeName("Name", "WICMetadataWriter")] + WicmetadataWriter = 0x10, + [Obsolete("Deprecated in favour of \"PixelFormat\"")] + [NativeName("Name", "WICPixelFormat")] + WicpixelFormat = 0x20, + [Obsolete("Deprecated in favour of \"AllComponents\"")] + [NativeName("Name", "WICAllComponents")] + WicallComponents = 0x3F, + [Obsolete("Deprecated in favour of \"OmponenttypeForceDword\"")] + [NativeName("Name", "WICCOMPONENTTYPE_FORCE_DWORD")] + WiccomponenttypeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICDecoder")] + Decoder = 0x1, + [NativeName("Name", "WICEncoder")] + Encoder = 0x2, + [NativeName("Name", "WICPixelFormatConverter")] + PixelFormatConverter = 0x4, + [NativeName("Name", "WICMetadataReader")] + MetadataReader = 0x8, + [NativeName("Name", "WICMetadataWriter")] + MetadataWriter = 0x10, + [NativeName("Name", "WICPixelFormat")] + PixelFormat = 0x20, + [NativeName("Name", "WICAllComponents")] + AllComponents = 0x3F, + [NativeName("Name", "WICCOMPONENTTYPE_FORCE_DWORD")] + OmponenttypeForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs new file mode 100644 index 0000000000..066749e20c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICDdsAlphaMode")] + public enum WICDdsAlphaMode : int + { + [Obsolete("Deprecated in favour of \"DdsAlphaModeUnknown\"")] + [NativeName("Name", "WICDdsAlphaModeUnknown")] + WicddsAlphaModeUnknown = 0x0, + [Obsolete("Deprecated in favour of \"DdsAlphaModeStraight\"")] + [NativeName("Name", "WICDdsAlphaModeStraight")] + WicddsAlphaModeStraight = 0x1, + [Obsolete("Deprecated in favour of \"DdsAlphaModePremultiplied\"")] + [NativeName("Name", "WICDdsAlphaModePremultiplied")] + WicddsAlphaModePremultiplied = 0x2, + [Obsolete("Deprecated in favour of \"DdsAlphaModeOpaque\"")] + [NativeName("Name", "WICDdsAlphaModeOpaque")] + WicddsAlphaModeOpaque = 0x3, + [Obsolete("Deprecated in favour of \"DdsAlphaModeCustom\"")] + [NativeName("Name", "WICDdsAlphaModeCustom")] + WicddsAlphaModeCustom = 0x4, + [Obsolete("Deprecated in favour of \"DsalphamodeForceDword\"")] + [NativeName("Name", "WICDDSALPHAMODE_FORCE_DWORD")] + WicddsalphamodeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICDdsAlphaModeUnknown")] + DdsAlphaModeUnknown = 0x0, + [NativeName("Name", "WICDdsAlphaModeStraight")] + DdsAlphaModeStraight = 0x1, + [NativeName("Name", "WICDdsAlphaModePremultiplied")] + DdsAlphaModePremultiplied = 0x2, + [NativeName("Name", "WICDdsAlphaModeOpaque")] + DdsAlphaModeOpaque = 0x3, + [NativeName("Name", "WICDdsAlphaModeCustom")] + DdsAlphaModeCustom = 0x4, + [NativeName("Name", "WICDDSALPHAMODE_FORCE_DWORD")] + DsalphamodeForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs new file mode 100644 index 0000000000..8b6f142954 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICDdsDimension")] + public enum WICDdsDimension : int + { + [Obsolete("Deprecated in favour of \"DdsTexture1D\"")] + [NativeName("Name", "WICDdsTexture1D")] + WicddsTexture1D = 0x0, + [Obsolete("Deprecated in favour of \"DdsTexture2D\"")] + [NativeName("Name", "WICDdsTexture2D")] + WicddsTexture2D = 0x1, + [Obsolete("Deprecated in favour of \"DdsTexture3D\"")] + [NativeName("Name", "WICDdsTexture3D")] + WicddsTexture3D = 0x2, + [Obsolete("Deprecated in favour of \"DdsTextureCube\"")] + [NativeName("Name", "WICDdsTextureCube")] + WicddsTextureCube = 0x3, + [Obsolete("Deprecated in favour of \"DstextureForceDword\"")] + [NativeName("Name", "WICDDSTEXTURE_FORCE_DWORD")] + WicddstextureForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICDdsTexture1D")] + DdsTexture1D = 0x0, + [NativeName("Name", "WICDdsTexture2D")] + DdsTexture2D = 0x1, + [NativeName("Name", "WICDdsTexture3D")] + DdsTexture3D = 0x2, + [NativeName("Name", "WICDdsTextureCube")] + DdsTextureCube = 0x3, + [NativeName("Name", "WICDDSTEXTURE_FORCE_DWORD")] + DstextureForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs new file mode 100644 index 0000000000..49b5fabe22 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICDecodeOptions")] + public enum WICDecodeOptions : int + { + [Obsolete("Deprecated in favour of \"DecodeMetadataCacheOnDemand\"")] + [NativeName("Name", "WICDecodeMetadataCacheOnDemand")] + WicdecodeMetadataCacheOnDemand = 0x0, + [Obsolete("Deprecated in favour of \"DecodeMetadataCacheOnLoad\"")] + [NativeName("Name", "WICDecodeMetadataCacheOnLoad")] + WicdecodeMetadataCacheOnLoad = 0x1, + [Obsolete("Deprecated in favour of \"EtadatacacheoptionForceDword\"")] + [NativeName("Name", "WICMETADATACACHEOPTION_FORCE_DWORD")] + WicmetadatacacheoptionForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICDecodeMetadataCacheOnDemand")] + DecodeMetadataCacheOnDemand = 0x0, + [NativeName("Name", "WICDecodeMetadataCacheOnLoad")] + DecodeMetadataCacheOnLoad = 0x1, + [NativeName("Name", "WICMETADATACACHEOPTION_FORCE_DWORD")] + EtadatacacheoptionForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs new file mode 100644 index 0000000000..f557063fd9 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICGifApplicationExtensionProperties")] + public enum WICGifApplicationExtensionProperties : int + { + [Obsolete("Deprecated in favour of \"Application\"")] + [NativeName("Name", "WICGifApplicationExtensionApplication")] + WicgifApplicationExtensionApplication = 0x1, + [Obsolete("Deprecated in favour of \"Data\"")] + [NativeName("Name", "WICGifApplicationExtensionData")] + WicgifApplicationExtensionData = 0x2, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICGifApplicationExtensionProperties_FORCE_DWORD")] + WicgifApplicationExtensionPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICGifApplicationExtensionApplication")] + Application = 0x1, + [NativeName("Name", "WICGifApplicationExtensionData")] + Data = 0x2, + [NativeName("Name", "WICGifApplicationExtensionProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs new file mode 100644 index 0000000000..d832031db4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICGifCommentExtensionProperties")] + public enum WICGifCommentExtensionProperties : int + { + [Obsolete("Deprecated in favour of \"Text\"")] + [NativeName("Name", "WICGifCommentExtensionText")] + WicgifCommentExtensionText = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICGifCommentExtensionProperties_FORCE_DWORD")] + WicgifCommentExtensionPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICGifCommentExtensionText")] + Text = 0x1, + [NativeName("Name", "WICGifCommentExtensionProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs new file mode 100644 index 0000000000..320f4ec490 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICGifGraphicControlExtensionProperties")] + public enum WICGifGraphicControlExtensionProperties : int + { + [Obsolete("Deprecated in favour of \"Disposal\"")] + [NativeName("Name", "WICGifGraphicControlExtensionDisposal")] + WicgifGraphicControlExtensionDisposal = 0x1, + [Obsolete("Deprecated in favour of \"UserInputFlag\"")] + [NativeName("Name", "WICGifGraphicControlExtensionUserInputFlag")] + WicgifGraphicControlExtensionUserInputFlag = 0x2, + [Obsolete("Deprecated in favour of \"TransparencyFlag\"")] + [NativeName("Name", "WICGifGraphicControlExtensionTransparencyFlag")] + WicgifGraphicControlExtensionTransparencyFlag = 0x3, + [Obsolete("Deprecated in favour of \"Delay\"")] + [NativeName("Name", "WICGifGraphicControlExtensionDelay")] + WicgifGraphicControlExtensionDelay = 0x4, + [Obsolete("Deprecated in favour of \"TransparentColorIndex\"")] + [NativeName("Name", "WICGifGraphicControlExtensionTransparentColorIndex")] + WicgifGraphicControlExtensionTransparentColorIndex = 0x5, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICGifGraphicControlExtensionProperties_FORCE_DWORD")] + WicgifGraphicControlExtensionPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICGifGraphicControlExtensionDisposal")] + Disposal = 0x1, + [NativeName("Name", "WICGifGraphicControlExtensionUserInputFlag")] + UserInputFlag = 0x2, + [NativeName("Name", "WICGifGraphicControlExtensionTransparencyFlag")] + TransparencyFlag = 0x3, + [NativeName("Name", "WICGifGraphicControlExtensionDelay")] + Delay = 0x4, + [NativeName("Name", "WICGifGraphicControlExtensionTransparentColorIndex")] + TransparentColorIndex = 0x5, + [NativeName("Name", "WICGifGraphicControlExtensionProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs new file mode 100644 index 0000000000..0ccae64a82 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICGifImageDescriptorProperties")] + public enum WICGifImageDescriptorProperties : int + { + [Obsolete("Deprecated in favour of \"Left\"")] + [NativeName("Name", "WICGifImageDescriptorLeft")] + WicgifImageDescriptorLeft = 0x1, + [Obsolete("Deprecated in favour of \"Top\"")] + [NativeName("Name", "WICGifImageDescriptorTop")] + WicgifImageDescriptorTop = 0x2, + [Obsolete("Deprecated in favour of \"Width\"")] + [NativeName("Name", "WICGifImageDescriptorWidth")] + WicgifImageDescriptorWidth = 0x3, + [Obsolete("Deprecated in favour of \"Height\"")] + [NativeName("Name", "WICGifImageDescriptorHeight")] + WicgifImageDescriptorHeight = 0x4, + [Obsolete("Deprecated in favour of \"LocalColorTableFlag\"")] + [NativeName("Name", "WICGifImageDescriptorLocalColorTableFlag")] + WicgifImageDescriptorLocalColorTableFlag = 0x5, + [Obsolete("Deprecated in favour of \"InterlaceFlag\"")] + [NativeName("Name", "WICGifImageDescriptorInterlaceFlag")] + WicgifImageDescriptorInterlaceFlag = 0x6, + [Obsolete("Deprecated in favour of \"SortFlag\"")] + [NativeName("Name", "WICGifImageDescriptorSortFlag")] + WicgifImageDescriptorSortFlag = 0x7, + [Obsolete("Deprecated in favour of \"LocalColorTableSize\"")] + [NativeName("Name", "WICGifImageDescriptorLocalColorTableSize")] + WicgifImageDescriptorLocalColorTableSize = 0x8, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICGifImageDescriptorProperties_FORCE_DWORD")] + WicgifImageDescriptorPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICGifImageDescriptorLeft")] + Left = 0x1, + [NativeName("Name", "WICGifImageDescriptorTop")] + Top = 0x2, + [NativeName("Name", "WICGifImageDescriptorWidth")] + Width = 0x3, + [NativeName("Name", "WICGifImageDescriptorHeight")] + Height = 0x4, + [NativeName("Name", "WICGifImageDescriptorLocalColorTableFlag")] + LocalColorTableFlag = 0x5, + [NativeName("Name", "WICGifImageDescriptorInterlaceFlag")] + InterlaceFlag = 0x6, + [NativeName("Name", "WICGifImageDescriptorSortFlag")] + SortFlag = 0x7, + [NativeName("Name", "WICGifImageDescriptorLocalColorTableSize")] + LocalColorTableSize = 0x8, + [NativeName("Name", "WICGifImageDescriptorProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs new file mode 100644 index 0000000000..0536d27490 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs @@ -0,0 +1,66 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICGifLogicalScreenDescriptorProperties")] + public enum WICGifLogicalScreenDescriptorProperties : int + { + [Obsolete("Deprecated in favour of \"Signature\"")] + [NativeName("Name", "WICGifLogicalScreenSignature")] + WicgifLogicalScreenSignature = 0x1, + [Obsolete("Deprecated in favour of \"DescriptorWidth\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorWidth")] + WicgifLogicalScreenDescriptorWidth = 0x2, + [Obsolete("Deprecated in favour of \"DescriptorHeight\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorHeight")] + WicgifLogicalScreenDescriptorHeight = 0x3, + [Obsolete("Deprecated in favour of \"DescriptorGlobalColorTableFlag\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorGlobalColorTableFlag")] + WicgifLogicalScreenDescriptorGlobalColorTableFlag = 0x4, + [Obsolete("Deprecated in favour of \"DescriptorColorResolution\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorColorResolution")] + WicgifLogicalScreenDescriptorColorResolution = 0x5, + [Obsolete("Deprecated in favour of \"DescriptorSortFlag\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorSortFlag")] + WicgifLogicalScreenDescriptorSortFlag = 0x6, + [Obsolete("Deprecated in favour of \"DescriptorGlobalColorTableSize\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorGlobalColorTableSize")] + WicgifLogicalScreenDescriptorGlobalColorTableSize = 0x7, + [Obsolete("Deprecated in favour of \"DescriptorBackgroundColorIndex\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorBackgroundColorIndex")] + WicgifLogicalScreenDescriptorBackgroundColorIndex = 0x8, + [Obsolete("Deprecated in favour of \"DescriptorPixelAspectRatio\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorPixelAspectRatio")] + WicgifLogicalScreenDescriptorPixelAspectRatio = 0x9, + [Obsolete("Deprecated in favour of \"DescriptorPropertiesForceDword\"")] + [NativeName("Name", "WICGifLogicalScreenDescriptorProperties_FORCE_DWORD")] + WicgifLogicalScreenDescriptorPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICGifLogicalScreenSignature")] + Signature = 0x1, + [NativeName("Name", "WICGifLogicalScreenDescriptorWidth")] + DescriptorWidth = 0x2, + [NativeName("Name", "WICGifLogicalScreenDescriptorHeight")] + DescriptorHeight = 0x3, + [NativeName("Name", "WICGifLogicalScreenDescriptorGlobalColorTableFlag")] + DescriptorGlobalColorTableFlag = 0x4, + [NativeName("Name", "WICGifLogicalScreenDescriptorColorResolution")] + DescriptorColorResolution = 0x5, + [NativeName("Name", "WICGifLogicalScreenDescriptorSortFlag")] + DescriptorSortFlag = 0x6, + [NativeName("Name", "WICGifLogicalScreenDescriptorGlobalColorTableSize")] + DescriptorGlobalColorTableSize = 0x7, + [NativeName("Name", "WICGifLogicalScreenDescriptorBackgroundColorIndex")] + DescriptorBackgroundColorIndex = 0x8, + [NativeName("Name", "WICGifLogicalScreenDescriptorPixelAspectRatio")] + DescriptorPixelAspectRatio = 0x9, + [NativeName("Name", "WICGifLogicalScreenDescriptorProperties_FORCE_DWORD")] + DescriptorPropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs new file mode 100644 index 0000000000..14198d135b --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICHeifHdrProperties")] + public enum WICHeifHdrProperties : int + { + [Obsolete("Deprecated in favour of \"MaximumLuminanceLevel\"")] + [NativeName("Name", "WICHeifHdrMaximumLuminanceLevel")] + WicheifHdrMaximumLuminanceLevel = 0x1, + [Obsolete("Deprecated in favour of \"MaximumFrameAverageLuminanceLevel\"")] + [NativeName("Name", "WICHeifHdrMaximumFrameAverageLuminanceLevel")] + WicheifHdrMaximumFrameAverageLuminanceLevel = 0x2, + [Obsolete("Deprecated in favour of \"MinimumMasteringDisplayLuminanceLevel\"")] + [NativeName("Name", "WICHeifHdrMinimumMasteringDisplayLuminanceLevel")] + WicheifHdrMinimumMasteringDisplayLuminanceLevel = 0x3, + [Obsolete("Deprecated in favour of \"MaximumMasteringDisplayLuminanceLevel\"")] + [NativeName("Name", "WICHeifHdrMaximumMasteringDisplayLuminanceLevel")] + WicheifHdrMaximumMasteringDisplayLuminanceLevel = 0x4, + [Obsolete("Deprecated in favour of \"CustomVideoPrimaries\"")] + [NativeName("Name", "WICHeifHdrCustomVideoPrimaries")] + WicheifHdrCustomVideoPrimaries = 0x5, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICHeifHdrProperties_FORCE_DWORD")] + WicheifHdrPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICHeifHdrMaximumLuminanceLevel")] + MaximumLuminanceLevel = 0x1, + [NativeName("Name", "WICHeifHdrMaximumFrameAverageLuminanceLevel")] + MaximumFrameAverageLuminanceLevel = 0x2, + [NativeName("Name", "WICHeifHdrMinimumMasteringDisplayLuminanceLevel")] + MinimumMasteringDisplayLuminanceLevel = 0x3, + [NativeName("Name", "WICHeifHdrMaximumMasteringDisplayLuminanceLevel")] + MaximumMasteringDisplayLuminanceLevel = 0x4, + [NativeName("Name", "WICHeifHdrCustomVideoPrimaries")] + CustomVideoPrimaries = 0x5, + [NativeName("Name", "WICHeifHdrProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs new file mode 100644 index 0000000000..e9cb26e2e4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICHeifProperties")] + public enum WICHeifProperties : int + { + [Obsolete("Deprecated in favour of \"Orientation\"")] + [NativeName("Name", "WICHeifOrientation")] + WicheifOrientation = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICHeifProperties_FORCE_DWORD")] + WicheifPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICHeifOrientation")] + Orientation = 0x1, + [NativeName("Name", "WICHeifProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs new file mode 100644 index 0000000000..4e46fde898 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegChrominanceProperties")] + public enum WICJpegChrominanceProperties : int + { + [Obsolete("Deprecated in favour of \"Table\"")] + [NativeName("Name", "WICJpegChrominanceTable")] + WicjpegChrominanceTable = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICJpegChrominanceProperties_FORCE_DWORD")] + WicjpegChrominancePropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegChrominanceTable")] + Table = 0x1, + [NativeName("Name", "WICJpegChrominanceProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs new file mode 100644 index 0000000000..d4f7421eea --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegCommentProperties")] + public enum WICJpegCommentProperties : int + { + [Obsolete("Deprecated in favour of \"Text\"")] + [NativeName("Name", "WICJpegCommentText")] + WicjpegCommentText = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICJpegCommentProperties_FORCE_DWORD")] + WicjpegCommentPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegCommentText")] + Text = 0x1, + [NativeName("Name", "WICJpegCommentProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs new file mode 100644 index 0000000000..1f632d9772 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegIndexingOptions")] + public enum WICJpegIndexingOptions : int + { + [Obsolete("Deprecated in favour of \"GenerateOnDemand\"")] + [NativeName("Name", "WICJpegIndexingOptionsGenerateOnDemand")] + WicjpegIndexingOptionsGenerateOnDemand = 0x0, + [Obsolete("Deprecated in favour of \"GenerateOnLoad\"")] + [NativeName("Name", "WICJpegIndexingOptionsGenerateOnLoad")] + WicjpegIndexingOptionsGenerateOnLoad = 0x1, + [Obsolete("Deprecated in favour of \"ForceDword\"")] + [NativeName("Name", "WICJpegIndexingOptions_FORCE_DWORD")] + WicjpegIndexingOptionsForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegIndexingOptionsGenerateOnDemand")] + GenerateOnDemand = 0x0, + [NativeName("Name", "WICJpegIndexingOptionsGenerateOnLoad")] + GenerateOnLoad = 0x1, + [NativeName("Name", "WICJpegIndexingOptions_FORCE_DWORD")] + ForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs new file mode 100644 index 0000000000..0672bf66a3 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegLuminanceProperties")] + public enum WICJpegLuminanceProperties : int + { + [Obsolete("Deprecated in favour of \"Table\"")] + [NativeName("Name", "WICJpegLuminanceTable")] + WicjpegLuminanceTable = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICJpegLuminanceProperties_FORCE_DWORD")] + WicjpegLuminancePropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegLuminanceTable")] + Table = 0x1, + [NativeName("Name", "WICJpegLuminanceProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs new file mode 100644 index 0000000000..7adeb9e780 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegScanType")] + public enum WICJpegScanType : int + { + [Obsolete("Deprecated in favour of \"Interleaved\"")] + [NativeName("Name", "WICJpegScanTypeInterleaved")] + WicjpegScanTypeInterleaved = 0x0, + [Obsolete("Deprecated in favour of \"PlanarComponents\"")] + [NativeName("Name", "WICJpegScanTypePlanarComponents")] + WicjpegScanTypePlanarComponents = 0x1, + [Obsolete("Deprecated in favour of \"Progressive\"")] + [NativeName("Name", "WICJpegScanTypeProgressive")] + WicjpegScanTypeProgressive = 0x2, + [Obsolete("Deprecated in favour of \"ForceDword\"")] + [NativeName("Name", "WICJpegScanType_FORCE_DWORD")] + WicjpegScanTypeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegScanTypeInterleaved")] + Interleaved = 0x0, + [NativeName("Name", "WICJpegScanTypePlanarComponents")] + PlanarComponents = 0x1, + [NativeName("Name", "WICJpegScanTypeProgressive")] + Progressive = 0x2, + [NativeName("Name", "WICJpegScanType_FORCE_DWORD")] + ForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs new file mode 100644 index 0000000000..30e427edce --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegTransferMatrix")] + public enum WICJpegTransferMatrix : int + { + [Obsolete("Deprecated in favour of \"Identity\"")] + [NativeName("Name", "WICJpegTransferMatrixIdentity")] + WicjpegTransferMatrixIdentity = 0x0, + [Obsolete("Deprecated in favour of \"BT601\"")] + [NativeName("Name", "WICJpegTransferMatrixBT601")] + WicjpegTransferMatrixBT601 = 0x1, + [Obsolete("Deprecated in favour of \"ForceDword\"")] + [NativeName("Name", "WICJpegTransferMatrix_FORCE_DWORD")] + WicjpegTransferMatrixForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegTransferMatrixIdentity")] + Identity = 0x0, + [NativeName("Name", "WICJpegTransferMatrixBT601")] + BT601 = 0x1, + [NativeName("Name", "WICJpegTransferMatrix_FORCE_DWORD")] + ForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs new file mode 100644 index 0000000000..ae46176e51 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegYCrCbSubsamplingOption")] + public enum WICJpegYCrCbSubsamplingOption : int + { + [Obsolete("Deprecated in favour of \"JpegYCrCbSubsamplingDefault\"")] + [NativeName("Name", "WICJpegYCrCbSubsamplingDefault")] + WicjpegYCrCbSubsamplingDefault = 0x0, + [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling420\"")] + [NativeName("Name", "WICJpegYCrCbSubsampling420")] + WicjpegYCrCbSubsampling420 = 0x1, + [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling422\"")] + [NativeName("Name", "WICJpegYCrCbSubsampling422")] + WicjpegYCrCbSubsampling422 = 0x2, + [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling444\"")] + [NativeName("Name", "WICJpegYCrCbSubsampling444")] + WicjpegYCrCbSubsampling444 = 0x3, + [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling440\"")] + [NativeName("Name", "WICJpegYCrCbSubsampling440")] + WicjpegYCrCbSubsampling440 = 0x4, + [Obsolete("Deprecated in favour of \"PegycrcbsubsamplingForceDword\"")] + [NativeName("Name", "WICJPEGYCRCBSUBSAMPLING_FORCE_DWORD")] + WicjpegycrcbsubsamplingForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICJpegYCrCbSubsamplingDefault")] + JpegYCrCbSubsamplingDefault = 0x0, + [NativeName("Name", "WICJpegYCrCbSubsampling420")] + JpegYCrCbSubsampling420 = 0x1, + [NativeName("Name", "WICJpegYCrCbSubsampling422")] + JpegYCrCbSubsampling422 = 0x2, + [NativeName("Name", "WICJpegYCrCbSubsampling444")] + JpegYCrCbSubsampling444 = 0x3, + [NativeName("Name", "WICJpegYCrCbSubsampling440")] + JpegYCrCbSubsampling440 = 0x4, + [NativeName("Name", "WICJPEGYCRCBSUBSAMPLING_FORCE_DWORD")] + PegycrcbsubsamplingForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs new file mode 100644 index 0000000000..5981508d1f --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICMetadataCreationOptions")] + public enum WICMetadataCreationOptions : int + { + [Obsolete("Deprecated in favour of \"Default\"")] + [NativeName("Name", "WICMetadataCreationDefault")] + WicmetadataCreationDefault = 0x0, + [Obsolete("Deprecated in favour of \"AllowUnknown\"")] + [NativeName("Name", "WICMetadataCreationAllowUnknown")] + WicmetadataCreationAllowUnknown = 0x0, + [Obsolete("Deprecated in favour of \"FailUnknown\"")] + [NativeName("Name", "WICMetadataCreationFailUnknown")] + WicmetadataCreationFailUnknown = 0x10000, + [Obsolete("Deprecated in favour of \"Mask\"")] + [NativeName("Name", "WICMetadataCreationMask")] + WicmetadataCreationMask = unchecked((int) 0xFFFFFFFFFFFF0000), + [NativeName("Name", "WICMetadataCreationDefault")] + Default = 0x0, + [NativeName("Name", "WICMetadataCreationAllowUnknown")] + AllowUnknown = 0x0, + [NativeName("Name", "WICMetadataCreationFailUnknown")] + FailUnknown = 0x10000, + [NativeName("Name", "WICMetadataCreationMask")] + Mask = unchecked((int) 0xFFFFFFFFFFFF0000), + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs new file mode 100644 index 0000000000..bc3262a44c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs @@ -0,0 +1,79 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICNamedWhitePoint")] + public enum WICNamedWhitePoint : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"WhitePointDefault\"")] + [NativeName("Name", "WICWhitePointDefault")] + WicwhitePointDefault = 0x1, + [Obsolete("Deprecated in favour of \"WhitePointDaylight\"")] + [NativeName("Name", "WICWhitePointDaylight")] + WicwhitePointDaylight = 0x2, + [Obsolete("Deprecated in favour of \"WhitePointCloudy\"")] + [NativeName("Name", "WICWhitePointCloudy")] + WicwhitePointCloudy = 0x4, + [Obsolete("Deprecated in favour of \"WhitePointShade\"")] + [NativeName("Name", "WICWhitePointShade")] + WicwhitePointShade = 0x8, + [Obsolete("Deprecated in favour of \"WhitePointTungsten\"")] + [NativeName("Name", "WICWhitePointTungsten")] + WicwhitePointTungsten = 0x10, + [Obsolete("Deprecated in favour of \"WhitePointFluorescent\"")] + [NativeName("Name", "WICWhitePointFluorescent")] + WicwhitePointFluorescent = 0x20, + [Obsolete("Deprecated in favour of \"WhitePointFlash\"")] + [NativeName("Name", "WICWhitePointFlash")] + WicwhitePointFlash = 0x40, + [Obsolete("Deprecated in favour of \"WhitePointUnderwater\"")] + [NativeName("Name", "WICWhitePointUnderwater")] + WicwhitePointUnderwater = 0x80, + [Obsolete("Deprecated in favour of \"WhitePointCustom\"")] + [NativeName("Name", "WICWhitePointCustom")] + WicwhitePointCustom = 0x100, + [Obsolete("Deprecated in favour of \"WhitePointAutoWhiteBalance\"")] + [NativeName("Name", "WICWhitePointAutoWhiteBalance")] + WicwhitePointAutoWhiteBalance = 0x200, + [Obsolete("Deprecated in favour of \"WhitePointAsShot\"")] + [NativeName("Name", "WICWhitePointAsShot")] + WicwhitePointAsShot = 0x1, + [Obsolete("Deprecated in favour of \"AmedwhitepointForceDword\"")] + [NativeName("Name", "WICNAMEDWHITEPOINT_FORCE_DWORD")] + WicnamedwhitepointForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICWhitePointDefault")] + WhitePointDefault = 0x1, + [NativeName("Name", "WICWhitePointDaylight")] + WhitePointDaylight = 0x2, + [NativeName("Name", "WICWhitePointCloudy")] + WhitePointCloudy = 0x4, + [NativeName("Name", "WICWhitePointShade")] + WhitePointShade = 0x8, + [NativeName("Name", "WICWhitePointTungsten")] + WhitePointTungsten = 0x10, + [NativeName("Name", "WICWhitePointFluorescent")] + WhitePointFluorescent = 0x20, + [NativeName("Name", "WICWhitePointFlash")] + WhitePointFlash = 0x40, + [NativeName("Name", "WICWhitePointUnderwater")] + WhitePointUnderwater = 0x80, + [NativeName("Name", "WICWhitePointCustom")] + WhitePointCustom = 0x100, + [NativeName("Name", "WICWhitePointAutoWhiteBalance")] + WhitePointAutoWhiteBalance = 0x200, + [NativeName("Name", "WICWhitePointAsShot")] + WhitePointAsShot = 0x1, + [NativeName("Name", "WICNAMEDWHITEPOINT_FORCE_DWORD")] + AmedwhitepointForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs new file mode 100644 index 0000000000..3cfaa00cb2 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs @@ -0,0 +1,52 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICPersistOptions")] + public enum WICPersistOptions : int + { + [Obsolete("Deprecated in favour of \"Default\"")] + [NativeName("Name", "WICPersistOptionDefault")] + WicpersistOptionDefault = 0x0, + [Obsolete("Deprecated in favour of \"LittleEndian\"")] + [NativeName("Name", "WICPersistOptionLittleEndian")] + WicpersistOptionLittleEndian = 0x0, + [Obsolete("Deprecated in favour of \"BigEndian\"")] + [NativeName("Name", "WICPersistOptionBigEndian")] + WicpersistOptionBigEndian = 0x1, + [Obsolete("Deprecated in favour of \"StrictFormat\"")] + [NativeName("Name", "WICPersistOptionStrictFormat")] + WicpersistOptionStrictFormat = 0x2, + [Obsolete("Deprecated in favour of \"NoCacheStream\"")] + [NativeName("Name", "WICPersistOptionNoCacheStream")] + WicpersistOptionNoCacheStream = 0x4, + [Obsolete("Deprecated in favour of \"PreferUtf8\"")] + [NativeName("Name", "WICPersistOptionPreferUTF8")] + WicpersistOptionPreferUtf8 = 0x8, + [Obsolete("Deprecated in favour of \"Mask\"")] + [NativeName("Name", "WICPersistOptionMask")] + WicpersistOptionMask = 0xFFFF, + [NativeName("Name", "WICPersistOptionDefault")] + Default = 0x0, + [NativeName("Name", "WICPersistOptionLittleEndian")] + LittleEndian = 0x0, + [NativeName("Name", "WICPersistOptionBigEndian")] + BigEndian = 0x1, + [NativeName("Name", "WICPersistOptionStrictFormat")] + StrictFormat = 0x2, + [NativeName("Name", "WICPersistOptionNoCacheStream")] + NoCacheStream = 0x4, + [NativeName("Name", "WICPersistOptionPreferUTF8")] + PreferUtf8 = 0x8, + [NativeName("Name", "WICPersistOptionMask")] + Mask = 0xFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs new file mode 100644 index 0000000000..c78420c310 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPixelFormatNumericRepresentation")] + public enum WICPixelFormatNumericRepresentation : int + { + [Obsolete("Deprecated in favour of \"Unspecified\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentationUnspecified")] + WicpixelFormatNumericRepresentationUnspecified = 0x0, + [Obsolete("Deprecated in favour of \"Indexed\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentationIndexed")] + WicpixelFormatNumericRepresentationIndexed = 0x1, + [Obsolete("Deprecated in favour of \"UnsignedInteger\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentationUnsignedInteger")] + WicpixelFormatNumericRepresentationUnsignedInteger = 0x2, + [Obsolete("Deprecated in favour of \"SignedInteger\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentationSignedInteger")] + WicpixelFormatNumericRepresentationSignedInteger = 0x3, + [Obsolete("Deprecated in favour of \"Fixed\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentationFixed")] + WicpixelFormatNumericRepresentationFixed = 0x4, + [Obsolete("Deprecated in favour of \"Float\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentationFloat")] + WicpixelFormatNumericRepresentationFloat = 0x5, + [Obsolete("Deprecated in favour of \"ForceDword\"")] + [NativeName("Name", "WICPixelFormatNumericRepresentation_FORCE_DWORD")] + WicpixelFormatNumericRepresentationForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPixelFormatNumericRepresentationUnspecified")] + Unspecified = 0x0, + [NativeName("Name", "WICPixelFormatNumericRepresentationIndexed")] + Indexed = 0x1, + [NativeName("Name", "WICPixelFormatNumericRepresentationUnsignedInteger")] + UnsignedInteger = 0x2, + [NativeName("Name", "WICPixelFormatNumericRepresentationSignedInteger")] + SignedInteger = 0x3, + [NativeName("Name", "WICPixelFormatNumericRepresentationFixed")] + Fixed = 0x4, + [NativeName("Name", "WICPixelFormatNumericRepresentationFloat")] + Float = 0x5, + [NativeName("Name", "WICPixelFormatNumericRepresentation_FORCE_DWORD")] + ForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs new file mode 100644 index 0000000000..916eda5a98 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPlanarOptions")] + public enum WICPlanarOptions : int + { + [Obsolete("Deprecated in favour of \"PlanarOptionsDefault\"")] + [NativeName("Name", "WICPlanarOptionsDefault")] + WicplanarOptionsDefault = 0x0, + [Obsolete("Deprecated in favour of \"PlanarOptionsPreserveSubsampling\"")] + [NativeName("Name", "WICPlanarOptionsPreserveSubsampling")] + WicplanarOptionsPreserveSubsampling = 0x1, + [Obsolete("Deprecated in favour of \"LanaroptionsForceDword\"")] + [NativeName("Name", "WICPLANAROPTIONS_FORCE_DWORD")] + WicplanaroptionsForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPlanarOptionsDefault")] + PlanarOptionsDefault = 0x0, + [NativeName("Name", "WICPlanarOptionsPreserveSubsampling")] + PlanarOptionsPreserveSubsampling = 0x1, + [NativeName("Name", "WICPLANAROPTIONS_FORCE_DWORD")] + LanaroptionsForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs new file mode 100644 index 0000000000..ae92414a45 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngBkgdProperties")] + public enum WICPngBkgdProperties : int + { + [Obsolete("Deprecated in favour of \"BackgroundColor\"")] + [NativeName("Name", "WICPngBkgdBackgroundColor")] + WicpngBkgdBackgroundColor = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngBkgdProperties_FORCE_DWORD")] + WicpngBkgdPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngBkgdBackgroundColor")] + BackgroundColor = 0x1, + [NativeName("Name", "WICPngBkgdProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs new file mode 100644 index 0000000000..f864b781d2 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngChrmProperties")] + public enum WICPngChrmProperties : int + { + [Obsolete("Deprecated in favour of \"WhitePointX\"")] + [NativeName("Name", "WICPngChrmWhitePointX")] + WicpngChrmWhitePointX = 0x1, + [Obsolete("Deprecated in favour of \"WhitePointY\"")] + [NativeName("Name", "WICPngChrmWhitePointY")] + WicpngChrmWhitePointY = 0x2, + [Obsolete("Deprecated in favour of \"RedX\"")] + [NativeName("Name", "WICPngChrmRedX")] + WicpngChrmRedX = 0x3, + [Obsolete("Deprecated in favour of \"RedY\"")] + [NativeName("Name", "WICPngChrmRedY")] + WicpngChrmRedY = 0x4, + [Obsolete("Deprecated in favour of \"GreenX\"")] + [NativeName("Name", "WICPngChrmGreenX")] + WicpngChrmGreenX = 0x5, + [Obsolete("Deprecated in favour of \"GreenY\"")] + [NativeName("Name", "WICPngChrmGreenY")] + WicpngChrmGreenY = 0x6, + [Obsolete("Deprecated in favour of \"BlueX\"")] + [NativeName("Name", "WICPngChrmBlueX")] + WicpngChrmBlueX = 0x7, + [Obsolete("Deprecated in favour of \"BlueY\"")] + [NativeName("Name", "WICPngChrmBlueY")] + WicpngChrmBlueY = 0x8, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngChrmProperties_FORCE_DWORD")] + WicpngChrmPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngChrmWhitePointX")] + WhitePointX = 0x1, + [NativeName("Name", "WICPngChrmWhitePointY")] + WhitePointY = 0x2, + [NativeName("Name", "WICPngChrmRedX")] + RedX = 0x3, + [NativeName("Name", "WICPngChrmRedY")] + RedY = 0x4, + [NativeName("Name", "WICPngChrmGreenX")] + GreenX = 0x5, + [NativeName("Name", "WICPngChrmGreenY")] + GreenY = 0x6, + [NativeName("Name", "WICPngChrmBlueX")] + BlueX = 0x7, + [NativeName("Name", "WICPngChrmBlueY")] + BlueY = 0x8, + [NativeName("Name", "WICPngChrmProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs new file mode 100644 index 0000000000..ba4a53b5d7 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs @@ -0,0 +1,56 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngFilterOption")] + public enum WICPngFilterOption : int + { + [Obsolete("Deprecated in favour of \"PngFilterUnspecified\"")] + [NativeName("Name", "WICPngFilterUnspecified")] + WicpngFilterUnspecified = 0x0, + [Obsolete("Deprecated in favour of \"PngFilterNone\"")] + [NativeName("Name", "WICPngFilterNone")] + WicpngFilterNone = 0x1, + [Obsolete("Deprecated in favour of \"PngFilterSub\"")] + [NativeName("Name", "WICPngFilterSub")] + WicpngFilterSub = 0x2, + [Obsolete("Deprecated in favour of \"PngFilterUp\"")] + [NativeName("Name", "WICPngFilterUp")] + WicpngFilterUp = 0x3, + [Obsolete("Deprecated in favour of \"PngFilterAverage\"")] + [NativeName("Name", "WICPngFilterAverage")] + WicpngFilterAverage = 0x4, + [Obsolete("Deprecated in favour of \"PngFilterPaeth\"")] + [NativeName("Name", "WICPngFilterPaeth")] + WicpngFilterPaeth = 0x5, + [Obsolete("Deprecated in favour of \"PngFilterAdaptive\"")] + [NativeName("Name", "WICPngFilterAdaptive")] + WicpngFilterAdaptive = 0x6, + [Obsolete("Deprecated in favour of \"NgfilteroptionForceDword\"")] + [NativeName("Name", "WICPNGFILTEROPTION_FORCE_DWORD")] + WicpngfilteroptionForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngFilterUnspecified")] + PngFilterUnspecified = 0x0, + [NativeName("Name", "WICPngFilterNone")] + PngFilterNone = 0x1, + [NativeName("Name", "WICPngFilterSub")] + PngFilterSub = 0x2, + [NativeName("Name", "WICPngFilterUp")] + PngFilterUp = 0x3, + [NativeName("Name", "WICPngFilterAverage")] + PngFilterAverage = 0x4, + [NativeName("Name", "WICPngFilterPaeth")] + PngFilterPaeth = 0x5, + [NativeName("Name", "WICPngFilterAdaptive")] + PngFilterAdaptive = 0x6, + [NativeName("Name", "WICPNGFILTEROPTION_FORCE_DWORD")] + NgfilteroptionForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs new file mode 100644 index 0000000000..d3840f0ac6 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngGamaProperties")] + public enum WICPngGamaProperties : int + { + [Obsolete("Deprecated in favour of \"Gamma\"")] + [NativeName("Name", "WICPngGamaGamma")] + WicpngGamaGamma = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngGamaProperties_FORCE_DWORD")] + WicpngGamaPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngGamaGamma")] + Gamma = 0x1, + [NativeName("Name", "WICPngGamaProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs new file mode 100644 index 0000000000..c0a4fba3b5 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngHistProperties")] + public enum WICPngHistProperties : int + { + [Obsolete("Deprecated in favour of \"Frequencies\"")] + [NativeName("Name", "WICPngHistFrequencies")] + WicpngHistFrequencies = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngHistProperties_FORCE_DWORD")] + WicpngHistPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngHistFrequencies")] + Frequencies = 0x1, + [NativeName("Name", "WICPngHistProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs new file mode 100644 index 0000000000..bec8337980 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngIccpProperties")] + public enum WICPngIccpProperties : int + { + [Obsolete("Deprecated in favour of \"ProfileName\"")] + [NativeName("Name", "WICPngIccpProfileName")] + WicpngIccpProfileName = 0x1, + [Obsolete("Deprecated in favour of \"ProfileData\"")] + [NativeName("Name", "WICPngIccpProfileData")] + WicpngIccpProfileData = 0x2, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngIccpProperties_FORCE_DWORD")] + WicpngIccpPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngIccpProfileName")] + ProfileName = 0x1, + [NativeName("Name", "WICPngIccpProfileData")] + ProfileData = 0x2, + [NativeName("Name", "WICPngIccpProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs new file mode 100644 index 0000000000..df1158be37 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs @@ -0,0 +1,46 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngItxtProperties")] + public enum WICPngItxtProperties : int + { + [Obsolete("Deprecated in favour of \"Keyword\"")] + [NativeName("Name", "WICPngItxtKeyword")] + WicpngItxtKeyword = 0x1, + [Obsolete("Deprecated in favour of \"CompressionFlag\"")] + [NativeName("Name", "WICPngItxtCompressionFlag")] + WicpngItxtCompressionFlag = 0x2, + [Obsolete("Deprecated in favour of \"LanguageTag\"")] + [NativeName("Name", "WICPngItxtLanguageTag")] + WicpngItxtLanguageTag = 0x3, + [Obsolete("Deprecated in favour of \"TranslatedKeyword\"")] + [NativeName("Name", "WICPngItxtTranslatedKeyword")] + WicpngItxtTranslatedKeyword = 0x4, + [Obsolete("Deprecated in favour of \"Text\"")] + [NativeName("Name", "WICPngItxtText")] + WicpngItxtText = 0x5, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngItxtProperties_FORCE_DWORD")] + WicpngItxtPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngItxtKeyword")] + Keyword = 0x1, + [NativeName("Name", "WICPngItxtCompressionFlag")] + CompressionFlag = 0x2, + [NativeName("Name", "WICPngItxtLanguageTag")] + LanguageTag = 0x3, + [NativeName("Name", "WICPngItxtTranslatedKeyword")] + TranslatedKeyword = 0x4, + [NativeName("Name", "WICPngItxtText")] + Text = 0x5, + [NativeName("Name", "WICPngItxtProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs new file mode 100644 index 0000000000..d33685ae63 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngSrgbProperties")] + public enum WICPngSrgbProperties : int + { + [Obsolete("Deprecated in favour of \"RenderingIntent\"")] + [NativeName("Name", "WICPngSrgbRenderingIntent")] + WicpngSrgbRenderingIntent = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngSrgbProperties_FORCE_DWORD")] + WicpngSrgbPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngSrgbRenderingIntent")] + RenderingIntent = 0x1, + [NativeName("Name", "WICPngSrgbProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs new file mode 100644 index 0000000000..ced073cb70 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs @@ -0,0 +1,51 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICPngTimeProperties")] + public enum WICPngTimeProperties : int + { + [Obsolete("Deprecated in favour of \"Year\"")] + [NativeName("Name", "WICPngTimeYear")] + WicpngTimeYear = 0x1, + [Obsolete("Deprecated in favour of \"Month\"")] + [NativeName("Name", "WICPngTimeMonth")] + WicpngTimeMonth = 0x2, + [Obsolete("Deprecated in favour of \"Day\"")] + [NativeName("Name", "WICPngTimeDay")] + WicpngTimeDay = 0x3, + [Obsolete("Deprecated in favour of \"Hour\"")] + [NativeName("Name", "WICPngTimeHour")] + WicpngTimeHour = 0x4, + [Obsolete("Deprecated in favour of \"Minute\"")] + [NativeName("Name", "WICPngTimeMinute")] + WicpngTimeMinute = 0x5, + [Obsolete("Deprecated in favour of \"Second\"")] + [NativeName("Name", "WICPngTimeSecond")] + WicpngTimeSecond = 0x6, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICPngTimeProperties_FORCE_DWORD")] + WicpngTimePropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICPngTimeYear")] + Year = 0x1, + [NativeName("Name", "WICPngTimeMonth")] + Month = 0x2, + [NativeName("Name", "WICPngTimeDay")] + Day = 0x3, + [NativeName("Name", "WICPngTimeHour")] + Hour = 0x4, + [NativeName("Name", "WICPngTimeMinute")] + Minute = 0x5, + [NativeName("Name", "WICPngTimeSecond")] + Second = 0x6, + [NativeName("Name", "WICPngTimeProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs new file mode 100644 index 0000000000..137082765c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs @@ -0,0 +1,44 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICProgressNotification")] + public enum WICProgressNotification : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"ProgressNotificationBegin\"")] + [NativeName("Name", "WICProgressNotificationBegin")] + WicprogressNotificationBegin = 0x10000, + [Obsolete("Deprecated in favour of \"ProgressNotificationEnd\"")] + [NativeName("Name", "WICProgressNotificationEnd")] + WicprogressNotificationEnd = 0x20000, + [Obsolete("Deprecated in favour of \"ProgressNotificationFrequent\"")] + [NativeName("Name", "WICProgressNotificationFrequent")] + WicprogressNotificationFrequent = 0x40000, + [Obsolete("Deprecated in favour of \"ProgressNotificationAll\"")] + [NativeName("Name", "WICProgressNotificationAll")] + WicprogressNotificationAll = unchecked((int) 0xFFFFFFFFFFFF0000), + [Obsolete("Deprecated in favour of \"RogressnotificationForceDword\"")] + [NativeName("Name", "WICPROGRESSNOTIFICATION_FORCE_DWORD")] + WicprogressnotificationForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICProgressNotificationBegin")] + ProgressNotificationBegin = 0x10000, + [NativeName("Name", "WICProgressNotificationEnd")] + ProgressNotificationEnd = 0x20000, + [NativeName("Name", "WICProgressNotificationFrequent")] + ProgressNotificationFrequent = 0x40000, + [NativeName("Name", "WICProgressNotificationAll")] + ProgressNotificationAll = unchecked((int) 0xFFFFFFFFFFFF0000), + [NativeName("Name", "WICPROGRESSNOTIFICATION_FORCE_DWORD")] + RogressnotificationForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs new file mode 100644 index 0000000000..57967620fe --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs @@ -0,0 +1,39 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICProgressOperation")] + public enum WICProgressOperation : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"ProgressOperationCopyPixels\"")] + [NativeName("Name", "WICProgressOperationCopyPixels")] + WicprogressOperationCopyPixels = 0x1, + [Obsolete("Deprecated in favour of \"ProgressOperationWritePixels\"")] + [NativeName("Name", "WICProgressOperationWritePixels")] + WicprogressOperationWritePixels = 0x2, + [Obsolete("Deprecated in favour of \"ProgressOperationAll\"")] + [NativeName("Name", "WICProgressOperationAll")] + WicprogressOperationAll = 0xFFFF, + [Obsolete("Deprecated in favour of \"RogressoperationForceDword\"")] + [NativeName("Name", "WICPROGRESSOPERATION_FORCE_DWORD")] + WicprogressoperationForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICProgressOperationCopyPixels")] + ProgressOperationCopyPixels = 0x1, + [NativeName("Name", "WICProgressOperationWritePixels")] + ProgressOperationWritePixels = 0x2, + [NativeName("Name", "WICProgressOperationAll")] + ProgressOperationAll = 0xFFFF, + [NativeName("Name", "WICPROGRESSOPERATION_FORCE_DWORD")] + RogressoperationForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs new file mode 100644 index 0000000000..3144aa568d --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawCapabilities")] + public enum WICRawCapabilities : int + { + [Obsolete("Deprecated in favour of \"RawCapabilityNotSupported\"")] + [NativeName("Name", "WICRawCapabilityNotSupported")] + WicrawCapabilityNotSupported = 0x0, + [Obsolete("Deprecated in favour of \"RawCapabilityGetSupported\"")] + [NativeName("Name", "WICRawCapabilityGetSupported")] + WicrawCapabilityGetSupported = 0x1, + [Obsolete("Deprecated in favour of \"RawCapabilityFullySupported\"")] + [NativeName("Name", "WICRawCapabilityFullySupported")] + WicrawCapabilityFullySupported = 0x2, + [Obsolete("Deprecated in favour of \"AwcapabilitiesForceDword\"")] + [NativeName("Name", "WICRAWCAPABILITIES_FORCE_DWORD")] + WicrawcapabilitiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICRawCapabilityNotSupported")] + RawCapabilityNotSupported = 0x0, + [NativeName("Name", "WICRawCapabilityGetSupported")] + RawCapabilityGetSupported = 0x1, + [NativeName("Name", "WICRawCapabilityFullySupported")] + RawCapabilityFullySupported = 0x2, + [NativeName("Name", "WICRAWCAPABILITIES_FORCE_DWORD")] + AwcapabilitiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs new file mode 100644 index 0000000000..f72865286e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawParameterSet")] + public enum WICRawParameterSet : int + { + [Obsolete("Deprecated in favour of \"AsShotParameterSet\"")] + [NativeName("Name", "WICAsShotParameterSet")] + WicasShotParameterSet = 0x1, + [Obsolete("Deprecated in favour of \"UserAdjustedParameterSet\"")] + [NativeName("Name", "WICUserAdjustedParameterSet")] + WicuserAdjustedParameterSet = 0x2, + [Obsolete("Deprecated in favour of \"AutoAdjustedParameterSet\"")] + [NativeName("Name", "WICAutoAdjustedParameterSet")] + WicautoAdjustedParameterSet = 0x3, + [Obsolete("Deprecated in favour of \"AwparametersetForceDword\"")] + [NativeName("Name", "WICRAWPARAMETERSET_FORCE_DWORD")] + WicrawparametersetForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICAsShotParameterSet")] + AsShotParameterSet = 0x1, + [NativeName("Name", "WICUserAdjustedParameterSet")] + UserAdjustedParameterSet = 0x2, + [NativeName("Name", "WICAutoAdjustedParameterSet")] + AutoAdjustedParameterSet = 0x3, + [NativeName("Name", "WICRAWPARAMETERSET_FORCE_DWORD")] + AwparametersetForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs new file mode 100644 index 0000000000..2668bbefe5 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs @@ -0,0 +1,36 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawRenderMode")] + public enum WICRawRenderMode : int + { + [Obsolete("Deprecated in favour of \"RawRenderModeDraft\"")] + [NativeName("Name", "WICRawRenderModeDraft")] + WicrawRenderModeDraft = 0x1, + [Obsolete("Deprecated in favour of \"RawRenderModeNormal\"")] + [NativeName("Name", "WICRawRenderModeNormal")] + WicrawRenderModeNormal = 0x2, + [Obsolete("Deprecated in favour of \"RawRenderModeBestQuality\"")] + [NativeName("Name", "WICRawRenderModeBestQuality")] + WicrawRenderModeBestQuality = 0x3, + [Obsolete("Deprecated in favour of \"AwrendermodeForceDword\"")] + [NativeName("Name", "WICRAWRENDERMODE_FORCE_DWORD")] + WicrawrendermodeForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICRawRenderModeDraft")] + RawRenderModeDraft = 0x1, + [NativeName("Name", "WICRawRenderModeNormal")] + RawRenderModeNormal = 0x2, + [NativeName("Name", "WICRawRenderModeBestQuality")] + RawRenderModeBestQuality = 0x3, + [NativeName("Name", "WICRAWRENDERMODE_FORCE_DWORD")] + AwrendermodeForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs new file mode 100644 index 0000000000..c10d769241 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs @@ -0,0 +1,41 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawRotationCapabilities")] + public enum WICRawRotationCapabilities : int + { + [Obsolete("Deprecated in favour of \"RawRotationCapabilityNotSupported\"")] + [NativeName("Name", "WICRawRotationCapabilityNotSupported")] + WicrawRotationCapabilityNotSupported = 0x0, + [Obsolete("Deprecated in favour of \"RawRotationCapabilityGetSupported\"")] + [NativeName("Name", "WICRawRotationCapabilityGetSupported")] + WicrawRotationCapabilityGetSupported = 0x1, + [Obsolete("Deprecated in favour of \"RawRotationCapabilityNinetyDegreesSupported\"")] + [NativeName("Name", "WICRawRotationCapabilityNinetyDegreesSupported")] + WicrawRotationCapabilityNinetyDegreesSupported = 0x2, + [Obsolete("Deprecated in favour of \"RawRotationCapabilityFullySupported\"")] + [NativeName("Name", "WICRawRotationCapabilityFullySupported")] + WicrawRotationCapabilityFullySupported = 0x3, + [Obsolete("Deprecated in favour of \"AwrotationcapabilitiesForceDword\"")] + [NativeName("Name", "WICRAWROTATIONCAPABILITIES_FORCE_DWORD")] + WicrawrotationcapabilitiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICRawRotationCapabilityNotSupported")] + RawRotationCapabilityNotSupported = 0x0, + [NativeName("Name", "WICRawRotationCapabilityGetSupported")] + RawRotationCapabilityGetSupported = 0x1, + [NativeName("Name", "WICRawRotationCapabilityNinetyDegreesSupported")] + RawRotationCapabilityNinetyDegreesSupported = 0x2, + [NativeName("Name", "WICRawRotationCapabilityFullySupported")] + RawRotationCapabilityFullySupported = 0x3, + [NativeName("Name", "WICRAWROTATIONCAPABILITIES_FORCE_DWORD")] + AwrotationcapabilitiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs new file mode 100644 index 0000000000..1e51f451a4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs @@ -0,0 +1,34 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Flags] + [NativeName("Name", "WICSectionAccessLevel")] + public enum WICSectionAccessLevel : int + { + [NativeName("Name", "")] + None = 0, + [Obsolete("Deprecated in favour of \"Read\"")] + [NativeName("Name", "WICSectionAccessLevelRead")] + WicsectionAccessLevelRead = 0x1, + [Obsolete("Deprecated in favour of \"ReadWrite\"")] + [NativeName("Name", "WICSectionAccessLevelReadWrite")] + WicsectionAccessLevelReadWrite = 0x3, + [Obsolete("Deprecated in favour of \"ForceDword\"")] + [NativeName("Name", "WICSectionAccessLevel_FORCE_DWORD")] + WicsectionAccessLevelForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICSectionAccessLevelRead")] + Read = 0x1, + [NativeName("Name", "WICSectionAccessLevelReadWrite")] + ReadWrite = 0x3, + [NativeName("Name", "WICSectionAccessLevel_FORCE_DWORD")] + ForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs new file mode 100644 index 0000000000..a617f31d45 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICTiffCompressionOption")] + public enum WICTiffCompressionOption : int + { + [Obsolete("Deprecated in favour of \"TiffCompressionDontCare\"")] + [NativeName("Name", "WICTiffCompressionDontCare")] + WictiffCompressionDontCare = 0x0, + [Obsolete("Deprecated in favour of \"TiffCompressionNone\"")] + [NativeName("Name", "WICTiffCompressionNone")] + WictiffCompressionNone = 0x1, + [Obsolete("Deprecated in favour of \"TiffCompressionCcitt3\"")] + [NativeName("Name", "WICTiffCompressionCCITT3")] + WictiffCompressionCcitt3 = 0x2, + [Obsolete("Deprecated in favour of \"TiffCompressionCcitt4\"")] + [NativeName("Name", "WICTiffCompressionCCITT4")] + WictiffCompressionCcitt4 = 0x3, + [Obsolete("Deprecated in favour of \"TiffCompressionLzw\"")] + [NativeName("Name", "WICTiffCompressionLZW")] + WictiffCompressionLzw = 0x4, + [Obsolete("Deprecated in favour of \"TiffCompressionRle\"")] + [NativeName("Name", "WICTiffCompressionRLE")] + WictiffCompressionRle = 0x5, + [Obsolete("Deprecated in favour of \"TiffCompressionZip\"")] + [NativeName("Name", "WICTiffCompressionZIP")] + WictiffCompressionZip = 0x6, + [Obsolete("Deprecated in favour of \"TiffCompressionLzwhDifferencing\"")] + [NativeName("Name", "WICTiffCompressionLZWHDifferencing")] + WictiffCompressionLzwhdifferencing = 0x7, + [Obsolete("Deprecated in favour of \"IffcompressionoptionForceDword\"")] + [NativeName("Name", "WICTIFFCOMPRESSIONOPTION_FORCE_DWORD")] + WictiffcompressionoptionForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICTiffCompressionDontCare")] + TiffCompressionDontCare = 0x0, + [NativeName("Name", "WICTiffCompressionNone")] + TiffCompressionNone = 0x1, + [NativeName("Name", "WICTiffCompressionCCITT3")] + TiffCompressionCcitt3 = 0x2, + [NativeName("Name", "WICTiffCompressionCCITT4")] + TiffCompressionCcitt4 = 0x3, + [NativeName("Name", "WICTiffCompressionLZW")] + TiffCompressionLzw = 0x4, + [NativeName("Name", "WICTiffCompressionRLE")] + TiffCompressionRle = 0x5, + [NativeName("Name", "WICTiffCompressionZIP")] + TiffCompressionZip = 0x6, + [NativeName("Name", "WICTiffCompressionLZWHDifferencing")] + TiffCompressionLzwhDifferencing = 0x7, + [NativeName("Name", "WICTIFFCOMPRESSIONOPTION_FORCE_DWORD")] + IffcompressionoptionForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs new file mode 100644 index 0000000000..a24780d776 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICWebpAnimProperties")] + public enum WICWebpAnimProperties : int + { + [Obsolete("Deprecated in favour of \"LoopCount\"")] + [NativeName("Name", "WICWebpAnimLoopCount")] + WicwebpAnimLoopCount = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICWebpAnimProperties_FORCE_DWORD")] + WicwebpAnimPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICWebpAnimLoopCount")] + LoopCount = 0x1, + [NativeName("Name", "WICWebpAnimProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs new file mode 100644 index 0000000000..5be01c3fea --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs @@ -0,0 +1,26 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using Silk.NET.Core.Attributes; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICWebpAnmfProperties")] + public enum WICWebpAnmfProperties : int + { + [Obsolete("Deprecated in favour of \"FrameDuration\"")] + [NativeName("Name", "WICWebpAnmfFrameDuration")] + WicwebpAnmfFrameDuration = 0x1, + [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] + [NativeName("Name", "WICWebpAnmfProperties_FORCE_DWORD")] + WicwebpAnmfPropertiesForceDword = 0x7FFFFFFF, + [NativeName("Name", "WICWebpAnmfFrameDuration")] + FrameDuration = 0x1, + [NativeName("Name", "WICWebpAnmfProperties_FORCE_DWORD")] + PropertiesForceDword = 0x7FFFFFFF, + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs new file mode 100644 index 0000000000..1584802c36 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs @@ -0,0 +1,456 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000121-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICBitmap")] + public unsafe partial struct IWICBitmap : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000121-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICBitmap val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmap val) + => Unsafe.As(ref val); + + public IWICBitmap + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, IWICBitmapLock** ppILock) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); + return ret; + } + + /// To be documented. + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref IWICBitmapLock* ppILock) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapLock** ppILockPtr = &ppILock) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, IWICBitmapLock** ppILock) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcLockPtr = &prcLock) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref IWICBitmapLock* ppILock) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcLockPtr = &prcLock) + { + fixed (IWICBitmapLock** ppILockPtr = &ppILock) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int SetPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly int SetResolution(double dpiX, double dpiY) + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, dpiX, dpiY); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Lock(prcLock, flags, (IWICBitmapLock**) ppILock.GetAddressOf()); + } + + /// To be documented. + public readonly int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Lock(in prcLock, flags, (IWICBitmapLock**) ppILock.GetAddressOf()); + } + + /// To be documented. + public readonly int SetPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs new file mode 100644 index 0000000000..a57df38dc5 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs @@ -0,0 +1,418 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("e4fbcf03-223d-4e81-9333-d635556dd1b5")] + [NativeName("Name", "IWICBitmapClipper")] + public unsafe partial struct IWICBitmapClipper : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("e4fbcf03-223d-4e81-9333-d635556dd1b5"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICBitmapClipper val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapClipper val) + => Unsafe.As(ref val); + + public IWICBitmapClipper + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); + } + return ret; + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, prc); + } + + /// To be documented. + public readonly int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, in prc); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs new file mode 100644 index 0000000000..9a668d336a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs @@ -0,0 +1,1102 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("e87a44c4-b76e-4c47-8b09-298eb12a2714")] + [NativeName("Name", "IWICBitmapCodecInfo")] + public unsafe partial struct IWICBitmapCodecInfo : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("e87a44c4-b76e-4c47-8b09-298eb12a2714"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICComponentInfo(IWICBitmapCodecInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapCodecInfo val) + => Unsafe.As(ref val); + + public IWICBitmapCodecInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, ref uint pcActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, ref Guid pguidPixelFormats, uint* pcActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public readonly int GetPixelFormats(uint cFormats, ref Guid pguidPixelFormats, ref uint pcActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, char* wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, char* wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, ref char wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetColorManagementVersion(uint cchColorManagementVersion, ref char wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetColorManagementVersion(uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, char* wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, char* wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, ref char wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetMimeTypes(uint cchMimeTypes, ref char wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public readonly int GetMimeTypes(uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, char* wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, char* wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, ref char wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFileExtensions(uint cchFileExtensions, ref char wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public readonly int GetFileExtensions(uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportAnimation(int* pfSupportAnimation) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimation); + return ret; + } + + /// To be documented. + public readonly int DoesSupportAnimation(ref int pfSupportAnimation) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportAnimationPtr = &pfSupportAnimation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimationPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportChromakey(int* pfSupportChromakey) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakey); + return ret; + } + + /// To be documented. + public readonly int DoesSupportChromakey(ref int pfSupportChromakey) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportChromakeyPtr = &pfSupportChromakey) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakeyPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportLossless(int* pfSupportLossless) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLossless); + return ret; + } + + /// To be documented. + public readonly int DoesSupportLossless(ref int pfSupportLossless) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportLosslessPtr = &pfSupportLossless) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLosslessPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportMultiframe(int* pfSupportMultiframe) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframe); + return ret; + } + + /// To be documented. + public readonly int DoesSupportMultiframe(ref int pfSupportMultiframe) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportMultiframePtr = &pfSupportMultiframe) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatches); + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + } + return ret; + } + + /// To be documented. + public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecProgressNotification.gen.cs new file mode 100644 index 0000000000..5d08b11285 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecProgressNotification.gen.cs @@ -0,0 +1,153 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("64c1024e-c3cf-4462-8078-88c2b11c46d9")] + [NativeName("Name", "IWICBitmapCodecProgressNotification")] + public unsafe partial struct IWICBitmapCodecProgressNotification : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("64c1024e-c3cf-4462-8078-88c2b11c46d9"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapCodecProgressNotification val) + => Unsafe.As(ref val); + + public IWICBitmapCodecProgressNotification + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int RegisterProgressNotification(PfnProgressNotification pfnProgressNotification, void* pvData, uint dwProgressFlags) + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfnProgressNotification, pvData, dwProgressFlags); + return ret; + } + + /// To be documented. + public readonly int RegisterProgressNotification(PfnProgressNotification pfnProgressNotification, ref T0 pvData, uint dwProgressFlags) where T0 : unmanaged + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfnProgressNotification, pvDataPtr, dwProgressFlags); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapCodecProgressNotification*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs new file mode 100644 index 0000000000..38af3f4835 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs @@ -0,0 +1,505 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("9edde9e7-8dee-47ea-99df-e6faf2ed44bf")] + [NativeName("Name", "IWICBitmapDecoder")] + public unsafe partial struct IWICBitmapDecoder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("9edde9e7-8dee-47ea-99df-e6faf2ed44bf"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapDecoder val) + => Unsafe.As(ref val); + + public IWICBitmapDecoder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryCapability(Silk.NET.Core.Win32Extras.IStream* pIStream, uint* pdwCapability) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, pdwCapability); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryCapability(Silk.NET.Core.Win32Extras.IStream* pIStream, ref uint pdwCapability) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwCapabilityPtr = &pdwCapability) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, pdwCapabilityPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryCapability(ref Silk.NET.Core.Win32Extras.IStream pIStream, uint* pdwCapability) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, pdwCapability); + } + return ret; + } + + /// To be documented. + public readonly int QueryCapability(ref Silk.NET.Core.Win32Extras.IStream pIStream, ref uint pdwCapability) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (uint* pdwCapabilityPtr = &pdwCapability) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, pdwCapabilityPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IStream* pIStream, WICDecodeOptions cacheOptions) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, cacheOptions); + return ret; + } + + /// To be documented. + public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IStream pIStream, WICDecodeOptions cacheOptions) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, cacheOptions); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDecoderInfo(IWICBitmapDecoderInfo** ppIDecoderInfo) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIDecoderInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDecoderInfo(ref IWICBitmapDecoderInfo* ppIDecoderInfo) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoderInfo** ppIDecoderInfoPtr = &ppIDecoderInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIDecoderInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryReader(IWICMetadataQueryReader** ppIMetadataQueryReader) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReader); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryReader(ref IWICMetadataQueryReader* ppIMetadataQueryReader) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader** ppIMetadataQueryReaderPtr = &ppIMetadataQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPreview(IWICBitmapSource** ppIBitmapSource) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIBitmapSource); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPreview(ref IWICBitmapSource* ppIBitmapSource) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppIBitmapSourcePtr = &ppIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIBitmapSourcePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContexts, pcActualCount); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, ref uint pcActualCount) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContexts, pcActualCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref IWICColorContext* ppIColorContexts, uint* pcActualCount) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContextsPtr, pcActualCount); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref IWICColorContext* ppIColorContexts, ref uint pcActualCount) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContextsPtr, pcActualCountPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetThumbnail(IWICBitmapSource** ppIThumbnail) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIThumbnail); + return ret; + } + + /// To be documented. + public readonly unsafe int GetThumbnail(ref IWICBitmapSource* ppIThumbnail) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppIThumbnailPtr = &ppIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFrameCount(uint* pCount) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pCount); + return ret; + } + + /// To be documented. + public readonly int GetFrameCount(ref uint pCount) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pCountPtr = &pCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFrame(uint index, IWICBitmapFrameDecode** ppIBitmapFrame) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, index, ppIBitmapFrame); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFrame(uint index, ref IWICBitmapFrameDecode* ppIBitmapFrame) + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode** ppIBitmapFramePtr = &ppIBitmapFrame) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, index, ppIBitmapFramePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int QueryCapability(ComPtr pIStream, uint* pdwCapability) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->QueryCapability((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pdwCapability); + } + + /// To be documented. + public readonly int QueryCapability(ComPtr pIStream, ref uint pdwCapability) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->QueryCapability((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pdwCapability); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIStream, WICDecodeOptions cacheOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, cacheOptions); + } + + /// To be documented. + public readonly int GetDecoderInfo(ref ComPtr ppIDecoderInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetDecoderInfo((IWICBitmapDecoderInfo**) ppIDecoderInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int GetMetadataQueryReader(ref ComPtr ppIMetadataQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataQueryReader((IWICMetadataQueryReader**) ppIMetadataQueryReader.GetAddressOf()); + } + + /// To be documented. + public readonly int GetPreview(ref ComPtr ppIBitmapSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetPreview((IWICBitmapSource**) ppIBitmapSource.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref ComPtr ppIColorContexts, uint* pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), pcActualCount); + } + + /// To be documented. + public readonly int GetColorContexts(uint cCount, ref ComPtr ppIColorContexts, ref uint pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), ref pcActualCount); + } + + /// To be documented. + public readonly int GetThumbnail(ref ComPtr ppIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); + } + + /// To be documented. + public readonly int GetFrame(uint index, ref ComPtr ppIBitmapFrame) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetFrame(index, (IWICBitmapFrameDecode**) ppIBitmapFrame.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs new file mode 100644 index 0000000000..5cd71aae3b --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs @@ -0,0 +1,1306 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("d8cd007f-d08f-4191-9bfc-236ea7f0e4b5")] + [NativeName("Name", "IWICBitmapDecoderInfo")] + public unsafe partial struct IWICBitmapDecoderInfo : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("d8cd007f-d08f-4191-9bfc-236ea7f0e4b5"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapCodecInfo(IWICBitmapDecoderInfo val) + => Unsafe.As(ref val); + + public static implicit operator IWICComponentInfo(IWICBitmapDecoderInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapDecoderInfo val) + => Unsafe.As(ref val); + + public IWICBitmapDecoderInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, ref uint pcActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, ref Guid pguidPixelFormats, uint* pcActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public readonly int GetPixelFormats(uint cFormats, ref Guid pguidPixelFormats, ref uint pcActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, char* wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, char* wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, ref char wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetColorManagementVersion(uint cchColorManagementVersion, ref char wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetColorManagementVersion(uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, char* wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, char* wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, ref char wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetMimeTypes(uint cchMimeTypes, ref char wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public readonly int GetMimeTypes(uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, char* wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, char* wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, ref char wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFileExtensions(uint cchFileExtensions, ref char wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public readonly int GetFileExtensions(uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportAnimation(int* pfSupportAnimation) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimation); + return ret; + } + + /// To be documented. + public readonly int DoesSupportAnimation(ref int pfSupportAnimation) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportAnimationPtr = &pfSupportAnimation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimationPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportChromakey(int* pfSupportChromakey) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakey); + return ret; + } + + /// To be documented. + public readonly int DoesSupportChromakey(ref int pfSupportChromakey) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportChromakeyPtr = &pfSupportChromakey) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakeyPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportLossless(int* pfSupportLossless) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLossless); + return ret; + } + + /// To be documented. + public readonly int DoesSupportLossless(ref int pfSupportLossless) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportLosslessPtr = &pfSupportLossless) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLosslessPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportMultiframe(int* pfSupportMultiframe) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframe); + return ret; + } + + /// To be documented. + public readonly int DoesSupportMultiframe(ref int pfSupportMultiframe) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportMultiframePtr = &pfSupportMultiframe) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatches); + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + } + return ret; + } + + /// To be documented. + public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcPatternsPtr = &pcPatterns) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcPatternsPtr = &pcPatterns) + { + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + fixed (uint* pcPatternsPtr = &pcPatterns) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActual); + } + } + return ret; + } + + /// To be documented. + public readonly int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + fixed (uint* pcPatternsPtr = &pcPatterns) + { + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStream, pfMatches); + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Silk.NET.Core.Win32Extras.IStream* pIStream, ref int pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStream, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(ref Silk.NET.Core.Win32Extras.IStream pIStream, int* pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStreamPtr, pfMatches); + } + return ret; + } + + /// To be documented. + public readonly int MatchesPattern(ref Silk.NET.Core.Win32Extras.IStream pIStream, ref int pfMatches) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStreamPtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(IWICBitmapDecoder** ppIBitmapDecoder) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, ppIBitmapDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref IWICBitmapDecoder* ppIBitmapDecoder) + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIBitmapDecoderPtr = &ppIBitmapDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, ppIBitmapDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int MatchesPattern(ComPtr pIStream, int* pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MatchesPattern((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pfMatches); + } + + /// To be documented. + public readonly int MatchesPattern(ComPtr pIStream, ref int pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MatchesPattern((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pfMatches); + } + + /// To be documented. + public readonly int CreateInstance(ref ComPtr ppIBitmapDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((IWICBitmapDecoder**) ppIBitmapDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs new file mode 100644 index 0000000000..dedac5b76a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs @@ -0,0 +1,437 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000103-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICBitmapEncoder")] + public unsafe partial struct IWICBitmapEncoder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000103-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapEncoder val) + => Unsafe.As(ref val); + + public IWICBitmapEncoder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IStream* pIStream, WICBitmapEncoderCacheOption cacheOption) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, cacheOption); + return ret; + } + + /// To be documented. + public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IStream pIStream, WICBitmapEncoderCacheOption cacheOption) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, cacheOption); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetEncoderInfo(IWICBitmapEncoderInfo** ppIEncoderInfo) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIEncoderInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEncoderInfo(ref IWICBitmapEncoderInfo* ppIEncoderInfo) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoderInfo** ppIEncoderInfoPtr = &ppIEncoderInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIEncoderInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetColorContexts(uint cCount, IWICColorContext** ppIColorContext) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cCount, ppIColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int SetColorContexts(uint cCount, ref IWICColorContext* ppIColorContext) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cCount, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int SetPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetThumbnail(IWICBitmapSource* pIThumbnail) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIThumbnail); + return ret; + } + + /// To be documented. + public readonly int SetThumbnail(ref IWICBitmapSource pIThumbnail) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIThumbnailPtr = &pIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetPreview(IWICBitmapSource* pIPreview) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPreview); + return ret; + } + + /// To be documented. + public readonly int SetPreview(ref IWICBitmapSource pIPreview) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIPreviewPtr = &pIPreview) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPreviewPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptions); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptionsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptions); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptionsPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Commit() + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryWriter(IWICMetadataQueryWriter** ppIMetadataQueryWriter) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIMetadataQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryWriter(ref IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIMetadataQueryWriterPtr = &ppIMetadataQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIMetadataQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIStream, WICBitmapEncoderCacheOption cacheOption) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, cacheOption); + } + + /// To be documented. + public readonly int GetEncoderInfo(ref ComPtr ppIEncoderInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetEncoderInfo((IWICBitmapEncoderInfo**) ppIEncoderInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int SetColorContexts(uint cCount, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetColorContexts(cCount, (IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly int SetPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int SetThumbnail(ComPtr pIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetThumbnail((IWICBitmapSource*) pIThumbnail.Handle); + } + + /// To be documented. + public readonly int SetPreview(ComPtr pIPreview) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetPreview((IWICBitmapSource*) pIPreview.Handle); + } + + /// To be documented. + public readonly int CreateNewFrame(ref ComPtr ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref ppIEncoderOptions); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); + } + + /// To be documented. + public readonly int GetMetadataQueryWriter(ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataQueryWriter((IWICMetadataQueryWriter**) ppIMetadataQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs new file mode 100644 index 0000000000..b579b93179 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs @@ -0,0 +1,1134 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("94c9b4ee-a09f-4f92-8a1e-4a9bce7e76fb")] + [NativeName("Name", "IWICBitmapEncoderInfo")] + public unsafe partial struct IWICBitmapEncoderInfo : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("94c9b4ee-a09f-4f92-8a1e-4a9bce7e76fb"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapCodecInfo(IWICBitmapEncoderInfo val) + => Unsafe.As(ref val); + + public static implicit operator IWICComponentInfo(IWICBitmapEncoderInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapEncoderInfo val) + => Unsafe.As(ref val); + + public IWICBitmapEncoderInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pguidPixelFormats, ref uint pcActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, ref Guid pguidPixelFormats, uint* pcActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public readonly int GetPixelFormats(uint cFormats, ref Guid pguidPixelFormats, ref uint pcActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, char* wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, char* wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, ref char wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetColorManagementVersion(uint cchColorManagementVersion, ref char wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorManagementVersion(uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetColorManagementVersion(uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, char* wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, char* wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, ref char wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetMimeTypes(uint cchMimeTypes, ref char wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMimeTypes(uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public readonly int GetMimeTypes(uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, char* wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, char* wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, ref char wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFileExtensions(uint cchFileExtensions, ref char wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFileExtensions(uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, uint* pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public readonly int GetFileExtensions(uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, ref uint pcchActual) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportAnimation(int* pfSupportAnimation) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimation); + return ret; + } + + /// To be documented. + public readonly int DoesSupportAnimation(ref int pfSupportAnimation) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportAnimationPtr = &pfSupportAnimation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimationPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportChromakey(int* pfSupportChromakey) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakey); + return ret; + } + + /// To be documented. + public readonly int DoesSupportChromakey(ref int pfSupportChromakey) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportChromakeyPtr = &pfSupportChromakey) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakeyPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportLossless(int* pfSupportLossless) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLossless); + return ret; + } + + /// To be documented. + public readonly int DoesSupportLossless(ref int pfSupportLossless) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportLosslessPtr = &pfSupportLossless) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLosslessPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportMultiframe(int* pfSupportMultiframe) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframe); + return ret; + } + + /// To be documented. + public readonly int DoesSupportMultiframe(ref int pfSupportMultiframe) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportMultiframePtr = &pfSupportMultiframe) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatches); + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + } + return ret; + } + + /// To be documented. + public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, int* pfMatches) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, ref int pfMatches) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(IWICBitmapEncoder** ppIBitmapEncoder) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, ppIBitmapEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref IWICBitmapEncoder* ppIBitmapEncoder) + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoder** ppIBitmapEncoderPtr = &ppIBitmapEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, ppIBitmapEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateInstance(ref ComPtr ppIBitmapEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((IWICBitmapEncoder**) ppIBitmapEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs new file mode 100644 index 0000000000..4bfecf876a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs @@ -0,0 +1,383 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("5009834f-2d6a-41ce-9e1b-17c5aff7a782")] + [NativeName("Name", "IWICBitmapFlipRotator")] + public unsafe partial struct IWICBitmapFlipRotator : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("5009834f-2d6a-41ce-9e1b-17c5aff7a782"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICBitmapFlipRotator val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapFlipRotator val) + => Unsafe.As(ref val); + + public IWICBitmapFlipRotator + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, WICBitmapTransformOptions options) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, options); + return ret; + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pISource, WICBitmapTransformOptions options) + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, options); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int Initialize(ComPtr pISource, WICBitmapTransformOptions options) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, options); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs new file mode 100644 index 0000000000..431c21d99d --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs @@ -0,0 +1,476 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("3b16811b-6a43-4ec9-a813-3d930c13b940")] + [NativeName("Name", "IWICBitmapFrameDecode")] + public unsafe partial struct IWICBitmapFrameDecode : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3b16811b-6a43-4ec9-a813-3d930c13b940"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICBitmapFrameDecode val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapFrameDecode val) + => Unsafe.As(ref val); + + public IWICBitmapFrameDecode + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryReader(IWICMetadataQueryReader** ppIMetadataQueryReader) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReader); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryReader(ref IWICMetadataQueryReader* ppIMetadataQueryReader) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader** ppIMetadataQueryReaderPtr = &ppIMetadataQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCount); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, ref uint pcActualCount) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref IWICColorContext* ppIColorContexts, uint* pcActualCount) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCount); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref IWICColorContext* ppIColorContexts, ref uint pcActualCount) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCountPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetThumbnail(IWICBitmapSource** ppIThumbnail) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnail); + return ret; + } + + /// To be documented. + public readonly unsafe int GetThumbnail(ref IWICBitmapSource* ppIThumbnail) + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppIThumbnailPtr = &ppIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int GetMetadataQueryReader(ref ComPtr ppIMetadataQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataQueryReader((IWICMetadataQueryReader**) ppIMetadataQueryReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref ComPtr ppIColorContexts, uint* pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), pcActualCount); + } + + /// To be documented. + public readonly int GetColorContexts(uint cCount, ref ComPtr ppIColorContexts, ref uint pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), ref pcActualCount); + } + + /// To be documented. + public readonly int GetThumbnail(ref ComPtr ppIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs new file mode 100644 index 0000000000..6f0d3c956e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs @@ -0,0 +1,421 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000105-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICBitmapFrameEncode")] + public unsafe partial struct IWICBitmapFrameEncode : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000105-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapFrameEncode val) + => Unsafe.As(ref val); + + public IWICBitmapFrameEncode + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(Silk.NET.Core.Native.IUnknown* pIEncoderOptions) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptions); + return ret; + } + + /// To be documented. + public readonly int Initialize(ref Silk.NET.Core.Native.IUnknown pIEncoderOptions) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pIEncoderOptionsPtr = &pIEncoderOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptionsPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSize(uint uiWidth, uint uiHeight) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, uiWidth, uiHeight); + return ret; + } + + /// To be documented. + public readonly int SetResolution(double dpiX, double dpiY) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, dpiX, dpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int SetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int SetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetColorContexts(uint cCount, IWICColorContext** ppIColorContext) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cCount, ppIColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int SetColorContexts(uint cCount, ref IWICColorContext* ppIColorContext) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cCount, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int SetPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetThumbnail(IWICBitmapSource* pIThumbnail) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIThumbnail); + return ret; + } + + /// To be documented. + public readonly int SetThumbnail(ref IWICBitmapSource pIThumbnail) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIThumbnailPtr = &pIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WritePixels(uint lineCount, uint cbStride, uint cbBufferSize, byte* pbPixels) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, lineCount, cbStride, cbBufferSize, pbPixels); + return ret; + } + + /// To be documented. + public readonly int WritePixels(uint lineCount, uint cbStride, uint cbBufferSize, ref byte pbPixels) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbPixelsPtr = &pbPixels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, lineCount, cbStride, cbBufferSize, pbPixelsPtr); + } + return ret; + } + + /// To be documented. + public readonly int WritePixels(uint lineCount, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbPixels) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbPixelsPtr = (byte*) SilkMarshal.StringToPtr(pbPixels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, lineCount, cbStride, cbBufferSize, pbPixelsPtr); + SilkMarshal.Free((nint)pbPixelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, WICRect* prc) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, ref WICRect prc) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(ref IWICBitmapSource pIBitmapSource, WICRect* prc) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); + } + return ret; + } + + /// To be documented. + public readonly int WriteSource(ref IWICBitmapSource pIBitmapSource, ref WICRect prc) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int Commit() + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryWriter(IWICMetadataQueryWriter** ppIMetadataQueryWriter) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIMetadataQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryWriter(ref IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIMetadataQueryWriterPtr = &ppIMetadataQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIMetadataQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((Silk.NET.Core.Native.IUnknown*) pIEncoderOptions.Handle); + } + + /// To be documented. + public readonly int SetColorContexts(uint cCount, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetColorContexts(cCount, (IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly int SetPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int SetThumbnail(ComPtr pIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetThumbnail((IWICBitmapSource*) pIThumbnail.Handle); + } + + /// To be documented. + public readonly unsafe int WriteSource(ComPtr pIBitmapSource, WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource*) pIBitmapSource.Handle, prc); + } + + /// To be documented. + public readonly int WriteSource(ComPtr pIBitmapSource, ref WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource*) pIBitmapSource.Handle, ref prc); + } + + /// To be documented. + public readonly int GetMetadataQueryWriter(ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataQueryWriter((IWICMetadataQueryWriter**) ppIMetadataQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapLock.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapLock.gen.cs new file mode 100644 index 0000000000..ca9b335562 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapLock.gen.cs @@ -0,0 +1,294 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000123-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICBitmapLock")] + public unsafe partial struct IWICBitmapLock : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000123-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapLock val) + => Unsafe.As(ref val); + + public IWICBitmapLock + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetStride(uint* pcbStride) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcbStride); + return ret; + } + + /// To be documented. + public readonly int GetStride(ref uint pcbStride) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbStridePtr = &pcbStride) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcbStridePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataPointer(uint* pcbBufferSize, byte** ppbData) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSize, ppbData); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataPointer(uint* pcbBufferSize, ref byte* ppbData) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte** ppbDataPtr = &ppbData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSize, ppbDataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataPointer(ref uint pcbBufferSize, byte** ppbData) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbBufferSizePtr = &pcbBufferSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSizePtr, ppbData); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDataPointer(ref uint pcbBufferSize, ref byte* ppbData) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbBufferSizePtr = &pcbBufferSize) + { + fixed (byte** ppbDataPtr = &ppbData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSizePtr, ppbDataPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetDataPointer(uint* pcbBufferSize, string[] ppbDataSa) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppbData = (byte**) SilkMarshal.StringArrayToPtr(ppbDataSa); + var ret = @this->GetDataPointer(pcbBufferSize, ppbData); + SilkMarshal.CopyPtrToStringArray((nint) ppbData, ppbDataSa); + SilkMarshal.Free((nint) ppbData); + return ret; + } + + /// To be documented. + public readonly int GetDataPointer(ref uint pcbBufferSize, string[] ppbDataSa) + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // StringArrayOverloader + var ppbData = (byte**) SilkMarshal.StringArrayToPtr(ppbDataSa); + var ret = @this->GetDataPointer(ref pcbBufferSize, ppbData); + SilkMarshal.CopyPtrToStringArray((nint) ppbData, ppbDataSa); + SilkMarshal.Free((nint) ppbData); + return ret; + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapLock*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs new file mode 100644 index 0000000000..1397704f3f --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs @@ -0,0 +1,383 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000302-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICBitmapScaler")] + public unsafe partial struct IWICBitmapScaler : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000302-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICBitmapScaler val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapScaler val) + => Unsafe.As(ref val); + + public IWICBitmapScaler + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, uiWidth, uiHeight, mode); + return ret; + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, uiWidth, uiHeight, mode); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int Initialize(ComPtr pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, uiWidth, uiHeight, mode); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs new file mode 100644 index 0000000000..f95e66ebcb --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs @@ -0,0 +1,351 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000120-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICBitmapSource")] + public unsafe partial struct IWICBitmapSource : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000120-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapSource val) + => Unsafe.As(ref val); + + public IWICBitmapSource + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs new file mode 100644 index 0000000000..a0f39ab9ce --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs @@ -0,0 +1,386 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("3b16811b-6a43-4ec9-b713-3d5a0c13b940")] + [NativeName("Name", "IWICBitmapSourceTransform")] + public unsafe partial struct IWICBitmapSourceTransform : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3b16811b-6a43-4ec9-b713-3d5a0c13b940"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICBitmapSourceTransform val) + => Unsafe.As(ref val); + + public IWICBitmapSourceTransform + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClosestSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClosestSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClosestSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetClosestSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetClosestPixelFormat(Guid* pguidDstFormat) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidDstFormat); + return ret; + } + + /// To be documented. + public readonly int GetClosestPixelFormat(ref Guid pguidDstFormat) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidDstFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(WICBitmapTransformOptions dstTransform, int* pfIsSupported) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupported); + return ret; + } + + /// To be documented. + public readonly int DoesSupportTransform(WICBitmapTransformOptions dstTransform, ref int pfIsSupported) + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupportedPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs new file mode 100644 index 0000000000..c020d09127 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs @@ -0,0 +1,320 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("3c613a02-34b2-44ea-9a7c-45aea9c6fd6d")] + [NativeName("Name", "IWICColorContext")] + public unsafe partial struct IWICColorContext : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3c613a02-34b2-44ea-9a7c-45aea9c6fd6d"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICColorContext val) + => Unsafe.As(ref val); + + public IWICColorContext + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename); + return ret; + } + + /// To be documented. + public readonly int InitializeFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr); + } + return ret; + } + + /// To be documented. + public readonly int InitializeFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromMemory([Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pbBuffer, uint cbBufferSize) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pbBuffer, cbBufferSize); + return ret; + } + + /// To be documented. + public readonly int InitializeFromMemory([Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pbBuffer, uint cbBufferSize) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pbBufferPtr, cbBufferSize); + } + return ret; + } + + /// To be documented. + public readonly int InitializeFromMemory([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, uint cbBufferSize) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pbBufferPtr, cbBufferSize); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly int InitializeFromExifColorSpace(uint value) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, value); + return ret; + } + + /// To be documented. + public readonly unsafe int GetType(WICColorContextType* pType) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetType(ref WICColorContextType pType) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICColorContextType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetProfileBytes(uint cbBuffer, byte* pbBuffer, uint* pcbActual) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBuffer, pcbActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetProfileBytes(uint cbBuffer, byte* pbBuffer, ref uint pcbActual) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBuffer, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetProfileBytes(uint cbBuffer, ref byte pbBuffer, uint* pcbActual) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly int GetProfileBytes(uint cbBuffer, ref byte pbBuffer, ref uint pcbActual) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetProfileBytes(uint cbBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, uint* pcbActual) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActual); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly int GetProfileBytes(uint cbBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref uint pcbActual) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActualPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetExifColorSpace(uint* pValue) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pValue); + return ret; + } + + /// To be documented. + public readonly int GetExifColorSpace(ref uint pValue) + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pValuePtr = &pValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pValuePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs new file mode 100644 index 0000000000..5b976cc888 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs @@ -0,0 +1,706 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("b66f034f-d0e2-40ab-b436-6de39e321a94")] + [NativeName("Name", "IWICColorTransform")] + public unsafe partial struct IWICColorTransform : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b66f034f-d0e2-40ab-b436-6de39e321a94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICColorTransform val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICColorTransform val) + => Unsafe.As(ref val); + + public IWICColorTransform + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDest, pixelFmtDest); + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDest, pixelFmtDestPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDestPtr, pixelFmtDest); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDestPtr, pixelFmtDestPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDest, pixelFmtDest); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDest, pixelFmtDestPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDestPtr, pixelFmtDest); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDestPtr, pixelFmtDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDest, pixelFmtDest); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDest, pixelFmtDestPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDestPtr, pixelFmtDest); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDestPtr, pixelFmtDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDest, pixelFmtDest); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDest, pixelFmtDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDestPtr, pixelFmtDest); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDestPtr, pixelFmtDestPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, ref pixelFmtDest); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, ref pIContextDest, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, ref pIContextDest, ref pixelFmtDest); + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, ref pixelFmtDest); + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs new file mode 100644 index 0000000000..3dddac412b --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs @@ -0,0 +1,3514 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("412d0c3a-9650-44fa-af5b-dd2a06c8e8fb")] + [NativeName("Name", "IWICComponentFactory")] + public unsafe partial struct IWICComponentFactory : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("412d0c3a-9650-44fa-af5b-dd2a06c8e8fb"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICImagingFactory(IWICComponentFactory val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICComponentFactory val) + => Unsafe.As(ref val); + + public IWICComponentFactory + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(Guid* clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(Guid* clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(ref Guid clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(ref Guid clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreatePalette(IWICPalette** ppIPalette) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalette); + return ret; + } + + /// To be documented. + public readonly unsafe int CreatePalette(ref IWICPalette* ppIPalette) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette** ppIPalettePtr = &ppIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFormatConverter(IWICFormatConverter** ppIFormatConverter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFormatConverter(ref IWICFormatConverter* ppIFormatConverter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFormatConverter** ppIFormatConverterPtr = &ppIFormatConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapScaler(IWICBitmapScaler** ppIBitmapScaler) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScaler); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapScaler(ref IWICBitmapScaler* ppIBitmapScaler) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapScaler** ppIBitmapScalerPtr = &ppIBitmapScaler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScalerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapClipper(IWICBitmapClipper** ppIBitmapClipper) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipper); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapClipper(ref IWICBitmapClipper* ppIBitmapClipper) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapClipper** ppIBitmapClipperPtr = &ppIBitmapClipper) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipperPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFlipRotator(IWICBitmapFlipRotator** ppIBitmapFlipRotator) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotator); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFlipRotator(ref IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFlipRotator** ppIBitmapFlipRotatorPtr = &ppIBitmapFlipRotator) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotatorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream(IWICStream** ppIWICStream) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStream); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream(ref IWICStream* ppIWICStream) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICStream** ppIWICStreamPtr = &ppIWICStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorContext(IWICColorContext** ppIWICColorContext) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorContext(ref IWICColorContext* ppIWICColorContext) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIWICColorContextPtr = &ppIWICColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorTransformer(IWICColorTransform** ppIWICColorTransform) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransform); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorTransformer(ref IWICColorTransform* ppIWICColorTransform) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorTransform** ppIWICColorTransformPtr = &ppIWICColorTransform) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransformPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, IWICBitmap** ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(ref T0 hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(ref T0 hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentEnumerator(uint componentTypes, uint options, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknown) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknown); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentEnumerator(uint componentTypes, uint options, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumUnknown) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknownPtr = &ppIEnumUnknown) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStream, ppIReader); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStream, ppIReader); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendor, dwMetadataOptions, ppIWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendor, dwMetadataOptions, ppIWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendorPtr, dwMetadataOptions, ppIWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendorPtr, dwMetadataOptions, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendor, dwMetadataOptions, ppIWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendor, dwMetadataOptions, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwMetadataOptions, ppIWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwMetadataOptions, ppIWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendor, ppIWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendor, ppIWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendorPtr, ppIWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendorPtr, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendor, ppIWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendor, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendorPtr, ppIWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendorPtr, ppIWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryReaderFromBlockReader(IWICMetadataBlockReader* pIBlockReader, IWICMetadataQueryReader** ppIQueryReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReader, ppIQueryReader); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryReaderFromBlockReader(IWICMetadataBlockReader* pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader** ppIQueryReaderPtr = &ppIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReader, ppIQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryReaderFromBlockReader(ref IWICMetadataBlockReader pIBlockReader, IWICMetadataQueryReader** ppIQueryReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataBlockReader* pIBlockReaderPtr = &pIBlockReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReaderPtr, ppIQueryReader); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryReaderFromBlockReader(ref IWICMetadataBlockReader pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataBlockReader* pIBlockReaderPtr = &pIBlockReader) + { + fixed (IWICMetadataQueryReader** ppIQueryReaderPtr = &ppIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReaderPtr, ppIQueryReaderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromBlockWriter(IWICMetadataBlockWriter* pIBlockWriter, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriter, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromBlockWriter(IWICMetadataBlockWriter* pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriter, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromBlockWriter(ref IWICMetadataBlockWriter pIBlockWriter, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataBlockWriter* pIBlockWriterPtr = &pIBlockWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriterPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromBlockWriter(ref IWICMetadataBlockWriter pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataBlockWriter* pIBlockWriterPtr = &pIBlockWriter) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriterPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoderPropertyBag(void* ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBag); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoderPropertyBag(void* ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBagPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoderPropertyBag(ref T0 ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* ppropOptionsPtr = &ppropOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBag); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoderPropertyBag(ref T0 ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) where T0 : unmanaged + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* ppropOptionsPtr = &ppropOptions) + { + fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBagPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateComponentInfo(out ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIInfo = default; + return @this->CreateComponentInfo(SilkMarshal.GuidPtrOf(), (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateComponentInfo(ref Guid clsidComponent, ref ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateComponentInfo(ref clsidComponent, (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoder(ref Guid guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoder(ref Guid guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreatePalette(ref ComPtr ppIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreatePalette((IWICPalette**) ppIPalette.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFormatConverter(ref ComPtr ppIFormatConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFormatConverter((IWICFormatConverter**) ppIFormatConverter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapScaler(ref ComPtr ppIBitmapScaler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapScaler((IWICBitmapScaler**) ppIBitmapScaler.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapClipper(ref ComPtr ppIBitmapClipper) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapClipper((IWICBitmapClipper**) ppIBitmapClipper.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFlipRotator(ref ComPtr ppIBitmapFlipRotator) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFlipRotator((IWICBitmapFlipRotator**) ppIBitmapFlipRotator.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStream(ref ComPtr ppIWICStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStream((IWICStream**) ppIWICStream.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateColorContext(ref ComPtr ppIWICColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateColorContext((IWICColorContext**) ppIWICColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateColorTransformer(ref ComPtr ppIWICColorTransform) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateColorTransformer((IWICColorTransform**) ppIWICColorTransform.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, ref ppIBitmap); + } + + /// To be documented. + public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromSourceRect(ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public readonly int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHICON(hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromHICON(ref T0 hIcon, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHICON(ref hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromDecoder(ComPtr pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ComPtr pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromFrameDecode(ComPtr pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ComPtr pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriter(ref Guid guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(ref guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ComPtr pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader(ref pIQueryReader, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly int CreateMetadataReader(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public readonly int CreateMetadataReaderFromContainer(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriter(guidMetadataFormat, pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriter(guidMetadataFormat, in pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat, pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateMetadataWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat, in pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateMetadataWriterFromReader(ComPtr pIReader, out ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIWriter = default; + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(ComPtr pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, pguidVendor, ref ppIWriter); + } + + /// To be documented. + public readonly int CreateMetadataWriterFromReader(ComPtr pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, in pguidVendor, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateMetadataWriterFromReader(ComPtr pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataWriter* ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, in pguidVendor, ref ppIWriter); + } + + /// To be documented. + public readonly int CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader, out ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIWriter = default; + return @this->CreateMetadataWriterFromReader(ref pIReader, SilkMarshal.GuidPtrOf(), (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader(ref pIReader, in pguidVendor, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryReaderFromBlockReader(ComPtr pIBlockReader, ref ComPtr ppIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryReaderFromBlockReader((IWICMetadataBlockReader*) pIBlockReader.Handle, (IWICMetadataQueryReader**) ppIQueryReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryReaderFromBlockReader(ComPtr pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryReaderFromBlockReader((IWICMetadataBlockReader*) pIBlockReader.Handle, ref ppIQueryReader); + } + + /// To be documented. + public readonly int CreateQueryReaderFromBlockReader(ref IWICMetadataBlockReader pIBlockReader, ref ComPtr ppIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryReaderFromBlockReader(ref pIBlockReader, (IWICMetadataQueryReader**) ppIQueryReader.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromBlockWriter(ComPtr pIBlockWriter, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromBlockWriter((IWICMetadataBlockWriter*) pIBlockWriter.Handle, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromBlockWriter(ComPtr pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromBlockWriter((IWICMetadataBlockWriter*) pIBlockWriter.Handle, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromBlockWriter(ref IWICMetadataBlockWriter pIBlockWriter, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromBlockWriter(ref pIBlockWriter, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoderPropertyBag(void* ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoderPropertyBag(ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoderPropertyBag(ref T0 ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoderPropertyBag(ref ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateComponentInfo() where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateComponentInfo(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateDecoder(Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateDecoder(ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateEncoder(Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateEncoder(ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateQueryWriter(Guid* guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriter(ref Guid guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(ref guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriterFromReader(ComPtr pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(ref pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateMetadataWriterFromReader(ComPtr pIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateMetadataWriterFromReader(pIReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateMetadataWriterFromReader(ref IWICMetadataReader pIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateMetadataWriterFromReader(ref pIReader, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs new file mode 100644 index 0000000000..29467fa8f6 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs @@ -0,0 +1,508 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("23bc3f0a-698b-4357-886b-f24d50671334")] + [NativeName("Name", "IWICComponentInfo")] + public unsafe partial struct IWICComponentInfo : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("23bc3f0a-698b-4357-886b-f24d50671334"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICComponentInfo val) + => Unsafe.As(ref val); + + public IWICComponentInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs new file mode 100644 index 0000000000..35b077c23e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs @@ -0,0 +1,182 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("409cd537-8532-40cb-9774-e2feb2df4e9c")] + [NativeName("Name", "IWICDdsDecoder")] + public unsafe partial struct IWICDdsDecoder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("409cd537-8532-40cb-9774-e2feb2df4e9c"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICDdsDecoder val) + => Unsafe.As(ref val); + + public IWICDdsDecoder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetParameters(WICDdsParameters* pParameters) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + return ret; + } + + /// To be documented. + public readonly int GetParameters(ref WICDdsParameters pParameters) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICDdsParameters* pParametersPtr = &pParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFrame(uint arrayIndex, uint mipLevel, uint sliceIndex, IWICBitmapFrameDecode** ppIBitmapFrame) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, arrayIndex, mipLevel, sliceIndex, ppIBitmapFrame); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFrame(uint arrayIndex, uint mipLevel, uint sliceIndex, ref IWICBitmapFrameDecode* ppIBitmapFrame) + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode** ppIBitmapFramePtr = &ppIBitmapFrame) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, arrayIndex, mipLevel, sliceIndex, ppIBitmapFramePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetFrame(uint arrayIndex, uint mipLevel, uint sliceIndex, ref ComPtr ppIBitmapFrame) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetFrame(arrayIndex, mipLevel, sliceIndex, (IWICBitmapFrameDecode**) ppIBitmapFrame.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs new file mode 100644 index 0000000000..f12cb43170 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs @@ -0,0 +1,478 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("5cacdb4c-407e-41b3-b936-d0f010cd6732")] + [NativeName("Name", "IWICDdsEncoder")] + public unsafe partial struct IWICDdsEncoder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("5cacdb4c-407e-41b3-b936-d0f010cd6732"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICDdsEncoder val) + => Unsafe.As(ref val); + + public IWICDdsEncoder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int SetParameters(WICDdsParameters* pParameters) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + return ret; + } + + /// To be documented. + public readonly int SetParameters(ref WICDdsParameters pParameters) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICDdsParameters* pParametersPtr = &pParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetParameters(WICDdsParameters* pParameters) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParameters); + return ret; + } + + /// To be documented. + public readonly int GetParameters(ref WICDdsParameters pParameters) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICDdsParameters* pParametersPtr = &pParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParametersPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevel, pSliceIndex); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevel, pSliceIndexPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevelPtr, pSliceIndex); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevelPtr, pSliceIndexPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevel, pSliceIndex); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevel, pSliceIndexPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevelPtr, pSliceIndex); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevelPtr, pSliceIndexPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevel, pSliceIndex); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevel, pSliceIndexPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevelPtr, pSliceIndex); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevelPtr, pSliceIndexPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevel, pSliceIndex); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevel, pSliceIndexPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevelPtr, pSliceIndex); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevelPtr, pSliceIndexPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, pMipLevel, pSliceIndex); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, ref pMipLevel, pSliceIndex); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, ref pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, pMipLevel, pSliceIndex); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public readonly unsafe int CreateNewFrame(ref ComPtr ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, ref pMipLevel, pSliceIndex); + } + + /// To be documented. + public readonly int CreateNewFrame(ref ComPtr ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, ref pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs new file mode 100644 index 0000000000..f697fe1e3d --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs @@ -0,0 +1,274 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("3d4c0c61-18a4-41e4-bd80-481a4fc9f464")] + [NativeName("Name", "IWICDdsFrameDecode")] + public unsafe partial struct IWICDdsFrameDecode : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3d4c0c61-18a4-41e4-bd80-481a4fc9f464"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICDdsFrameDecode val) + => Unsafe.As(ref val); + + public IWICDdsFrameDecode + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeInBlocks(uint* pWidthInBlocks, uint* pHeightInBlocks) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocks, pHeightInBlocks); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeInBlocks(uint* pWidthInBlocks, ref uint pHeightInBlocks) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pHeightInBlocksPtr = &pHeightInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocks, pHeightInBlocksPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeInBlocks(ref uint pWidthInBlocks, uint* pHeightInBlocks) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pWidthInBlocksPtr = &pWidthInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocksPtr, pHeightInBlocks); + } + return ret; + } + + /// To be documented. + public readonly int GetSizeInBlocks(ref uint pWidthInBlocks, ref uint pHeightInBlocks) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pWidthInBlocksPtr = &pWidthInBlocks) + { + fixed (uint* pHeightInBlocksPtr = &pHeightInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocksPtr, pHeightInBlocksPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFormatInfo(WICDdsFormatInfo* pFormatInfo) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfo); + return ret; + } + + /// To be documented. + public readonly int GetFormatInfo(ref WICDdsFormatInfo pFormatInfo) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICDdsFormatInfo* pFormatInfoPtr = &pFormatInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs new file mode 100644 index 0000000000..ca28b7c8e5 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs @@ -0,0 +1,1220 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("fbec5e44-f7be-4b65-b7f8-c0c81fef026d")] + [NativeName("Name", "IWICDevelopRaw")] + public unsafe partial struct IWICDevelopRaw : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("fbec5e44-f7be-4b65-b7f8-c0c81fef026d"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapFrameDecode(IWICDevelopRaw val) + => Unsafe.As(ref val); + + public static implicit operator IWICBitmapSource(IWICDevelopRaw val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICDevelopRaw val) + => Unsafe.As(ref val); + + public IWICDevelopRaw + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryReader(IWICMetadataQueryReader** ppIMetadataQueryReader) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReader); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryReader(ref IWICMetadataQueryReader* ppIMetadataQueryReader) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader** ppIMetadataQueryReaderPtr = &ppIMetadataQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCount); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, IWICColorContext** ppIColorContexts, ref uint pcActualCount) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref IWICColorContext* ppIColorContexts, uint* pcActualCount) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCount); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref IWICColorContext* ppIColorContexts, ref uint pcActualCount) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCountPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetThumbnail(IWICBitmapSource** ppIThumbnail) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnail); + return ret; + } + + /// To be documented. + public readonly unsafe int GetThumbnail(ref IWICBitmapSource* ppIThumbnail) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppIThumbnailPtr = &ppIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryRawCapabilitiesInfo(WICRawCapabilitiesInfo* pInfo) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfo); + return ret; + } + + /// To be documented. + public readonly int QueryRawCapabilitiesInfo(ref WICRawCapabilitiesInfo pInfo) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRawCapabilitiesInfo* pInfoPtr = &pInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly int LoadParameterSet(WICRawParameterSet ParameterSet) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ParameterSet); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCurrentParameterSet(Silk.NET.Core.Native.IUnknown** ppCurrentParameterSet) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSet); + return ret; + } + + /// To be documented. + public readonly unsafe int GetCurrentParameterSet(ref Silk.NET.Core.Native.IUnknown* ppCurrentParameterSet) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppCurrentParameterSetPtr = &ppCurrentParameterSet) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSetPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetExposureCompensation(double ev) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ev); + return ret; + } + + /// To be documented. + public readonly unsafe int GetExposureCompensation(double* pEV) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pEV); + return ret; + } + + /// To be documented. + public readonly int GetExposureCompensation(ref double pEV) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pEVPtr = &pEV) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pEVPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetWhitePointRGB(uint Red, uint Green, uint Blue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, Red, Green, Blue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(uint* pRed, uint* pGreen, uint* pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreen, pBlue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(uint* pRed, uint* pGreen, ref uint pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreen, pBluePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(uint* pRed, ref uint pGreen, uint* pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pGreenPtr = &pGreen) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreenPtr, pBlue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(uint* pRed, ref uint pGreen, ref uint pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pGreenPtr = &pGreen) + { + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreenPtr, pBluePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(ref uint pRed, uint* pGreen, uint* pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreen, pBlue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(ref uint pRed, uint* pGreen, ref uint pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreen, pBluePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointRGB(ref uint pRed, ref uint pGreen, uint* pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + fixed (uint* pGreenPtr = &pGreen) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreenPtr, pBlue); + } + } + return ret; + } + + /// To be documented. + public readonly int GetWhitePointRGB(ref uint pRed, ref uint pGreen, ref uint pBlue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + fixed (uint* pGreenPtr = &pGreen) + { + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreenPtr, pBluePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int SetNamedWhitePoint(WICNamedWhitePoint WhitePoint) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, WhitePoint); + return ret; + } + + /// To be documented. + public readonly unsafe int GetNamedWhitePoint(WICNamedWhitePoint* pWhitePoint) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePoint); + return ret; + } + + /// To be documented. + public readonly int GetNamedWhitePoint(ref WICNamedWhitePoint pWhitePoint) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICNamedWhitePoint* pWhitePointPtr = &pWhitePoint) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePointPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetWhitePointKelvin(uint WhitePointKelvin) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, WhitePointKelvin); + return ret; + } + + /// To be documented. + public readonly unsafe int GetWhitePointKelvin(uint* pWhitePointKelvin) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pWhitePointKelvin); + return ret; + } + + /// To be documented. + public readonly int GetWhitePointKelvin(ref uint pWhitePointKelvin) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pWhitePointKelvinPtr = &pWhitePointKelvin) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pWhitePointKelvinPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(uint* pMinKelvinTemp, uint* pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTemp, pKelvinTempStepValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(uint* pMinKelvinTemp, uint* pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTemp, pKelvinTempStepValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(uint* pMinKelvinTemp, ref uint pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTempPtr, pKelvinTempStepValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(uint* pMinKelvinTemp, ref uint pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTempPtr, pKelvinTempStepValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(ref uint pMinKelvinTemp, uint* pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTemp, pKelvinTempStepValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(ref uint pMinKelvinTemp, uint* pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTemp, pKelvinTempStepValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetKelvinRangeInfo(ref uint pMinKelvinTemp, ref uint pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTempPtr, pKelvinTempStepValue); + } + } + return ret; + } + + /// To be documented. + public readonly int GetKelvinRangeInfo(ref uint pMinKelvinTemp, ref uint pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTempPtr, pKelvinTempStepValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int SetContrast(double Contrast) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, Contrast); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContrast(double* pContrast) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pContrast); + return ret; + } + + /// To be documented. + public readonly int GetContrast(ref double pContrast) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pContrastPtr = &pContrast) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pContrastPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetGamma(double Gamma) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, Gamma); + return ret; + } + + /// To be documented. + public readonly unsafe int GetGamma(double* pGamma) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, pGamma); + return ret; + } + + /// To be documented. + public readonly int GetGamma(ref double pGamma) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pGammaPtr = &pGamma) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, pGammaPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSharpness(double Sharpness) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, Sharpness); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSharpness(double* pSharpness) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pSharpness); + return ret; + } + + /// To be documented. + public readonly int GetSharpness(ref double pSharpness) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pSharpnessPtr = &pSharpness) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pSharpnessPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSaturation(double Saturation) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, Saturation); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSaturation(double* pSaturation) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, pSaturation); + return ret; + } + + /// To be documented. + public readonly int GetSaturation(ref double pSaturation) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pSaturationPtr = &pSaturation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, pSaturationPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetTint(double Tint) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, Tint); + return ret; + } + + /// To be documented. + public readonly unsafe int GetTint(double* pTint) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pTint); + return ret; + } + + /// To be documented. + public readonly int GetTint(ref double pTint) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pTintPtr = &pTint) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pTintPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetNoiseReduction(double NoiseReduction) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, NoiseReduction); + return ret; + } + + /// To be documented. + public readonly unsafe int GetNoiseReduction(double* pNoiseReduction) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, pNoiseReduction); + return ret; + } + + /// To be documented. + public readonly int GetNoiseReduction(ref double pNoiseReduction) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pNoiseReductionPtr = &pNoiseReduction) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, pNoiseReductionPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetDestinationColorContext(IWICColorContext* pColorContext) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[35])(@this, pColorContext); + return ret; + } + + /// To be documented. + public readonly int SetDestinationColorContext(ref IWICColorContext pColorContext) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext* pColorContextPtr = &pColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[35])(@this, pColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetToneCurve(uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurve); + return ret; + } + + /// To be documented. + public readonly int SetToneCurve(uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurvePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + return ret; + } + + /// To be documented. + public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSize); + } + return ret; + } + + /// To be documented. + public readonly int GetToneCurve(uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + { + fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSizePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int SetRotation(double Rotation) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[38])(@this, Rotation); + return ret; + } + + /// To be documented. + public readonly unsafe int GetRotation(double* pRotation) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[39])(@this, pRotation); + return ret; + } + + /// To be documented. + public readonly int GetRotation(ref double pRotation) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pRotationPtr = &pRotation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[39])(@this, pRotationPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetRenderMode(WICRawRenderMode RenderMode) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[40])(@this, RenderMode); + return ret; + } + + /// To be documented. + public readonly unsafe int GetRenderMode(WICRawRenderMode* pRenderMode) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderMode); + return ret; + } + + /// To be documented. + public readonly int GetRenderMode(ref WICRawRenderMode pRenderMode) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRawRenderMode* pRenderModePtr = &pRenderMode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderModePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetNotificationCallback(IWICDevelopRawNotificationCallback* pCallback) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[42])(@this, pCallback); + return ret; + } + + /// To be documented. + public readonly int SetNotificationCallback(ref IWICDevelopRawNotificationCallback pCallback) + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICDevelopRawNotificationCallback* pCallbackPtr = &pCallback) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[42])(@this, pCallbackPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly int GetMetadataQueryReader(ref ComPtr ppIMetadataQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataQueryReader((IWICMetadataQueryReader**) ppIMetadataQueryReader.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int GetColorContexts(uint cCount, ref ComPtr ppIColorContexts, uint* pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), pcActualCount); + } + + /// To be documented. + public readonly int GetColorContexts(uint cCount, ref ComPtr ppIColorContexts, ref uint pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), ref pcActualCount); + } + + /// To be documented. + public readonly int GetThumbnail(ref ComPtr ppIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); + } + + /// To be documented. + public readonly int GetCurrentParameterSet(ref ComPtr ppCurrentParameterSet) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetCurrentParameterSet((Silk.NET.Core.Native.IUnknown**) ppCurrentParameterSet.GetAddressOf()); + } + + /// To be documented. + public readonly int SetDestinationColorContext(ComPtr pColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetDestinationColorContext((IWICColorContext*) pColorContext.Handle); + } + + /// To be documented. + public readonly int SetNotificationCallback(ComPtr pCallback) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetNotificationCallback((IWICDevelopRawNotificationCallback*) pCallback.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRawNotificationCallback.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRawNotificationCallback.gen.cs new file mode 100644 index 0000000000..4c866d4001 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRawNotificationCallback.gen.cs @@ -0,0 +1,141 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("95c75a6e-3e8c-4ec2-85a8-aebcc551e59b")] + [NativeName("Name", "IWICDevelopRawNotificationCallback")] + public unsafe partial struct IWICDevelopRawNotificationCallback : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("95c75a6e-3e8c-4ec2-85a8-aebcc551e59b"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICDevelopRawNotificationCallback val) + => Unsafe.As(ref val); + + public IWICDevelopRawNotificationCallback + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int Notify(uint NotificationMask) + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, NotificationMask); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICDevelopRawNotificationCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs new file mode 100644 index 0000000000..3cf2b33545 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICEnumMetadataItem.gen.cs @@ -0,0 +1,419 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("dc2bb46d-3f07-481e-8625-220c4aedbb33")] + [NativeName("Name", "IWICEnumMetadataItem")] + public unsafe partial struct IWICEnumMetadataItem : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("dc2bb46d-3f07-481e-8625-220c4aedbb33"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICEnumMetadataItem val) + => Unsafe.As(ref val); + + public IWICEnumMetadataItem + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, ref uint pceltFetched) where T0 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetched); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetched); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetched); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetchedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetched); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetched); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Next(uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int Skip(uint celt) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public readonly int Reset() + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(IWICEnumMetadataItem** ppIEnumMetadataItem) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataItem); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref IWICEnumMetadataItem* ppIEnumMetadataItem) + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICEnumMetadataItem** ppIEnumMetadataItemPtr = &ppIEnumMetadataItem) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataItemPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppIEnumMetadataItem) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((IWICEnumMetadataItem**) ppIEnumMetadataItem.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICEnumMetadataItem*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFastMetadataEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFastMetadataEncoder.gen.cs new file mode 100644 index 0000000000..9f0ecc2ad4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFastMetadataEncoder.gen.cs @@ -0,0 +1,170 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("b84e2c09-78c9-4ac4-8bd3-524ae1663a2f")] + [NativeName("Name", "IWICFastMetadataEncoder")] + public unsafe partial struct IWICFastMetadataEncoder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b84e2c09-78c9-4ac4-8bd3-524ae1663a2f"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICFastMetadataEncoder val) + => Unsafe.As(ref val); + + public IWICFastMetadataEncoder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int Commit() + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryWriter(IWICMetadataQueryWriter** ppIMetadataQueryWriter) + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIMetadataQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataQueryWriter(ref IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIMetadataQueryWriterPtr = &ppIMetadataQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIMetadataQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetMetadataQueryWriter(ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataQueryWriter((IWICMetadataQueryWriter**) ppIMetadataQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICFastMetadataEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs new file mode 100644 index 0000000000..091371ddaa --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs @@ -0,0 +1,618 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000301-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICFormatConverter")] + public unsafe partial struct IWICFormatConverter : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000301-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICFormatConverter val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICFormatConverter val) + => Unsafe.As(ref val); + + public IWICFormatConverter + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(Guid* srcPixelFormat, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormat, pfCanConvert); + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(Guid* srcPixelFormat, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormat, pfCanConvertPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(Guid* srcPixelFormat, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormatPtr, pfCanConvert); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(Guid* srcPixelFormat, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormatPtr, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(ref Guid srcPixelFormat, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormat, pfCanConvert); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(ref Guid srcPixelFormat, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormat, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert(ref Guid srcPixelFormat, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormatPtr, pfCanConvert); + } + } + return ret; + } + + /// To be documented. + public readonly int CanConvert(ref Guid srcPixelFormat, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormatPtr, pfCanConvertPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, ref dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pISource, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref pISource, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs new file mode 100644 index 0000000000..9ce8188f8a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs @@ -0,0 +1,588 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("9f34fb65-13f4-4f15-bc57-3726b5e53d9f")] + [NativeName("Name", "IWICFormatConverterInfo")] + public unsafe partial struct IWICFormatConverterInfo : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("9f34fb65-13f4-4f15-bc57-3726b5e53d9f"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICComponentInfo(IWICFormatConverterInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICFormatConverterInfo val) + => Unsafe.As(ref val); + + public IWICFormatConverterInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pPixelFormatGUIDs, uint* pcActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDs, pcActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, Guid* pPixelFormatGUIDs, ref uint pcActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDs, pcActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormats(uint cFormats, ref Guid pPixelFormatGUIDs, uint* pcActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatGUIDsPtr = &pPixelFormatGUIDs) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public readonly int GetPixelFormats(uint cFormats, ref Guid pPixelFormatGUIDs, ref uint pcActual) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatGUIDsPtr = &pPixelFormatGUIDs) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(IWICFormatConverter** ppIConverter) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIConverter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref IWICFormatConverter* ppIConverter) + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFormatConverter** ppIConverterPtr = &ppIConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIConverterPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateInstance(ref ComPtr ppIConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((IWICFormatConverter**) ppIConverter.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs new file mode 100644 index 0000000000..1e3fa62578 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs @@ -0,0 +1,552 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("04c75bf8-3ce1-473b-acc5-3cc4f5e94999")] + [NativeName("Name", "IWICImageEncoder")] + public unsafe partial struct IWICImageEncoder : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("04c75bf8-3ce1-473b-acc5-3cc4f5e94999"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICImageEncoder val) + => Unsafe.As(ref val); + + public IWICImageEncoder + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParameters); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParametersPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParameters); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParameters); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + } + } + return ret; + } + + /// To be documented. + public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParameters); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParametersPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParameters); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParameters); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + } + } + return ret; + } + + /// To be documented. + public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParameters); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParametersPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParameters); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParameters); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParameters); + } + } + return ret; + } + + /// To be documented. + public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParametersPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrame(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrame(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrame(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrame(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrameThumbnail(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrameThumbnail(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrameThumbnail(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteFrameThumbnail(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteThumbnail(pImage, (IWICBitmapEncoder*) pEncoder.Handle, pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteThumbnail(pImage, (IWICBitmapEncoder*) pEncoder.Handle, in pImageParameters); + } + + /// To be documented. + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteThumbnail(ref pImage, (IWICBitmapEncoder*) pEncoder.Handle, pImageParameters); + } + + /// To be documented. + public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteThumbnail(ref pImage, (IWICBitmapEncoder*) pEncoder.Handle, in pImageParameters); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs new file mode 100644 index 0000000000..19e2d36630 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs @@ -0,0 +1,2315 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("ec5ec8a9-c395-4314-9c77-54d7a935ff70")] + [NativeName("Name", "IWICImagingFactory")] + public unsafe partial struct IWICImagingFactory : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("ec5ec8a9-c395-4314-9c77-54d7a935ff70"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICImagingFactory val) + => Unsafe.As(ref val); + + public IWICImagingFactory + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(Guid* clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(Guid* clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(ref Guid clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(ref Guid clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreatePalette(IWICPalette** ppIPalette) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalette); + return ret; + } + + /// To be documented. + public readonly unsafe int CreatePalette(ref IWICPalette* ppIPalette) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette** ppIPalettePtr = &ppIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFormatConverter(IWICFormatConverter** ppIFormatConverter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFormatConverter(ref IWICFormatConverter* ppIFormatConverter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFormatConverter** ppIFormatConverterPtr = &ppIFormatConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapScaler(IWICBitmapScaler** ppIBitmapScaler) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScaler); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapScaler(ref IWICBitmapScaler* ppIBitmapScaler) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapScaler** ppIBitmapScalerPtr = &ppIBitmapScaler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScalerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapClipper(IWICBitmapClipper** ppIBitmapClipper) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipper); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapClipper(ref IWICBitmapClipper* ppIBitmapClipper) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapClipper** ppIBitmapClipperPtr = &ppIBitmapClipper) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipperPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFlipRotator(IWICBitmapFlipRotator** ppIBitmapFlipRotator) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotator); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFlipRotator(ref IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFlipRotator** ppIBitmapFlipRotatorPtr = &ppIBitmapFlipRotator) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotatorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream(IWICStream** ppIWICStream) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStream); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream(ref IWICStream* ppIWICStream) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICStream** ppIWICStreamPtr = &ppIWICStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorContext(IWICColorContext** ppIWICColorContext) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorContext(ref IWICColorContext* ppIWICColorContext) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIWICColorContextPtr = &ppIWICColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorTransformer(IWICColorTransform** ppIWICColorTransform) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransform); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorTransformer(ref IWICColorTransform* ppIWICColorTransform) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorTransform** ppIWICColorTransformPtr = &ppIWICColorTransform) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransformPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(ref T0 hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(ref T0 hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentEnumerator(uint componentTypes, uint options, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknown) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknown); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentEnumerator(uint componentTypes, uint options, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumUnknown) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknownPtr = &ppIEnumUnknown) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateComponentInfo(out ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIInfo = default; + return @this->CreateComponentInfo(SilkMarshal.GuidPtrOf(), (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateComponentInfo(ref Guid clsidComponent, ref ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateComponentInfo(ref clsidComponent, (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoder(ref Guid guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoder(ref Guid guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreatePalette(ref ComPtr ppIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreatePalette((IWICPalette**) ppIPalette.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFormatConverter(ref ComPtr ppIFormatConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFormatConverter((IWICFormatConverter**) ppIFormatConverter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapScaler(ref ComPtr ppIBitmapScaler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapScaler((IWICBitmapScaler**) ppIBitmapScaler.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapClipper(ref ComPtr ppIBitmapClipper) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapClipper((IWICBitmapClipper**) ppIBitmapClipper.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFlipRotator(ref ComPtr ppIBitmapFlipRotator) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFlipRotator((IWICBitmapFlipRotator**) ppIBitmapFlipRotator.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStream(ref ComPtr ppIWICStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStream((IWICStream**) ppIWICStream.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateColorContext(ref ComPtr ppIWICColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateColorContext((IWICColorContext**) ppIWICColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateColorTransformer(ref ComPtr ppIWICColorTransform) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateColorTransformer((IWICColorTransform**) ppIWICColorTransform.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, ref ppIBitmap); + } + + /// To be documented. + public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromSourceRect(ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public readonly int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHICON(hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromHICON(ref T0 hIcon, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHICON(ref hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromDecoder(ComPtr pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ComPtr pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromFrameDecode(ComPtr pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ComPtr pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriter(ref Guid guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(ref guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ComPtr pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader(ref pIQueryReader, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateComponentInfo() where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateComponentInfo(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateDecoder(Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateDecoder(ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateEncoder(Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateEncoder(ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateQueryWriter(Guid* guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriter(ref Guid guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(ref guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriterFromReader(ComPtr pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(ref pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs new file mode 100644 index 0000000000..4742ea8b23 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs @@ -0,0 +1,2382 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("7b816b45-1996-4476-b132-de9e247c8af0")] + [NativeName("Name", "IWICImagingFactory2")] + public unsafe partial struct IWICImagingFactory2 : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("7b816b45-1996-4476-b132-de9e247c8af0"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICImagingFactory(IWICImagingFactory2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICImagingFactory2 val) + => Unsafe.As(ref val); + + public IWICImagingFactory2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(Guid* clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfo); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(Guid* clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfoPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(ref Guid clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfo); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentInfo(ref Guid clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfoPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoder); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreatePalette(IWICPalette** ppIPalette) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalette); + return ret; + } + + /// To be documented. + public readonly unsafe int CreatePalette(ref IWICPalette* ppIPalette) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette** ppIPalettePtr = &ppIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFormatConverter(IWICFormatConverter** ppIFormatConverter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFormatConverter(ref IWICFormatConverter* ppIFormatConverter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFormatConverter** ppIFormatConverterPtr = &ppIFormatConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapScaler(IWICBitmapScaler** ppIBitmapScaler) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScaler); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapScaler(ref IWICBitmapScaler* ppIBitmapScaler) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapScaler** ppIBitmapScalerPtr = &ppIBitmapScaler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScalerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapClipper(IWICBitmapClipper** ppIBitmapClipper) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipper); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapClipper(ref IWICBitmapClipper* ppIBitmapClipper) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapClipper** ppIBitmapClipperPtr = &ppIBitmapClipper) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipperPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFlipRotator(IWICBitmapFlipRotator** ppIBitmapFlipRotator) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotator); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFlipRotator(ref IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFlipRotator** ppIBitmapFlipRotatorPtr = &ppIBitmapFlipRotator) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotatorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream(IWICStream** ppIWICStream) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStream); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateStream(ref IWICStream* ppIWICStream) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICStream** ppIWICStreamPtr = &ppIWICStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorContext(IWICColorContext** ppIWICColorContext) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorContext(ref IWICColorContext* ppIWICColorContext) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIWICColorContextPtr = &ppIWICColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorTransformer(IWICColorTransform** ppIWICColorTransform) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransform); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateColorTransformer(ref IWICColorTransform* ppIWICColorTransform) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorTransform** ppIWICColorTransformPtr = &ppIWICColorTransform) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransformPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, IWICBitmap** ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmap); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, ref IWICBitmap* ppIBitmap) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(ref T0 hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(ref T0 hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentEnumerator(uint componentTypes, uint options, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknown) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknown); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateComponentEnumerator(uint componentTypes, uint options, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumUnknown) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknownPtr = &ppIEnumUnknown) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(IWICBitmapDecoder* pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(IWICBitmapFrameDecode* pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateImageEncoder(Silk.NET.Direct2D.ID2D1Device* pD2DDevice, IWICImageEncoder** ppWICImageEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevice, ppWICImageEncoder); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateImageEncoder(Silk.NET.Direct2D.ID2D1Device* pD2DDevice, ref IWICImageEncoder* ppWICImageEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICImageEncoder** ppWICImageEncoderPtr = &ppWICImageEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevice, ppWICImageEncoderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateImageEncoder(ref Silk.NET.Direct2D.ID2D1Device pD2DDevice, IWICImageEncoder** ppWICImageEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Device* pD2DDevicePtr = &pD2DDevice) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevicePtr, ppWICImageEncoder); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateImageEncoder(ref Silk.NET.Direct2D.ID2D1Device pD2DDevice, ref IWICImageEncoder* ppWICImageEncoder) + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Device* pD2DDevicePtr = &pD2DDevice) + { + fixed (IWICImageEncoder** ppWICImageEncoderPtr = &ppWICImageEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevicePtr, ppWICImageEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateComponentInfo(out ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIInfo = default; + return @this->CreateComponentInfo(SilkMarshal.GuidPtrOf(), (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateComponentInfo(ref Guid clsidComponent, ref ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateComponentInfo(ref clsidComponent, (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateDecoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoder(ref Guid guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateDecoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateDecoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateEncoder(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoder(ref Guid guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateEncoder(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateEncoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreatePalette(ref ComPtr ppIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreatePalette((IWICPalette**) ppIPalette.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFormatConverter(ref ComPtr ppIFormatConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFormatConverter((IWICFormatConverter**) ppIFormatConverter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapScaler(ref ComPtr ppIBitmapScaler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapScaler((IWICBitmapScaler**) ppIBitmapScaler.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapClipper(ref ComPtr ppIBitmapClipper) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapClipper((IWICBitmapClipper**) ppIBitmapClipper.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFlipRotator(ref ComPtr ppIBitmapFlipRotator) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFlipRotator((IWICBitmapFlipRotator**) ppIBitmapFlipRotator.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateStream(ref ComPtr ppIWICStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateStream((IWICStream**) ppIWICStream.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateColorContext(ref ComPtr ppIWICColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateColorContext((IWICColorContext**) ppIWICColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateColorTransformer(ref ComPtr ppIWICColorTransform) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateColorTransformer((IWICColorTransform**) ppIWICColorTransform.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, ref ppIBitmap); + } + + /// To be documented. + public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromSourceRect(ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromSourceRect(ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public readonly int CreateBitmapFromSourceRect(ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateBitmapFromHICON(void* hIcon, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHICON(hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateBitmapFromHICON(ref T0 hIcon, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateBitmapFromHICON(ref hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromDecoder(ComPtr pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromDecoder(ComPtr pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromDecoder(ref IWICBitmapDecoder pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromFrameDecode(ComPtr pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateFastMetadataEncoderFromFrameDecode(ComPtr pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public readonly int CreateFastMetadataEncoderFromFrameDecode(ref IWICBitmapFrameDecode pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriter(Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriter(ref Guid guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(ref guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriter(ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ComPtr pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateQueryWriterFromReader(ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader(ref pIQueryReader, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CreateImageEncoder(Silk.NET.Direct2D.ID2D1Device* pD2DDevice, ref ComPtr ppWICImageEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateImageEncoder(pD2DDevice, (IWICImageEncoder**) ppWICImageEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateImageEncoder(ref Silk.NET.Direct2D.ID2D1Device pD2DDevice, ref ComPtr ppWICImageEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateImageEncoder(ref pD2DDevice, (IWICImageEncoder**) ppWICImageEncoder.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateComponentInfo() where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateComponentInfo(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateDecoder(Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateDecoder(ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateEncoder(Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateEncoder(ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly unsafe ComPtr CreateQueryWriter(Guid* guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriter(ref Guid guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(ref guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriterFromReader(ComPtr pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public readonly ComPtr CreateQueryWriterFromReader(ref IWICMetadataQueryReader pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(ref pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs new file mode 100644 index 0000000000..68049993a4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs @@ -0,0 +1,422 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("8939f66e-c46a-4c21-a9d1-98b327ce1679")] + [NativeName("Name", "IWICJpegFrameDecode")] + public unsafe partial struct IWICJpegFrameDecode : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("8939f66e-c46a-4c21-a9d1-98b327ce1679"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICJpegFrameDecode val) + => Unsafe.As(ref val); + + public IWICJpegFrameDecode + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportIndexing(int* pfIndexingSupported) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfIndexingSupported); + return ret; + } + + /// To be documented. + public readonly int DoesSupportIndexing(ref int pfIndexingSupported) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfIndexingSupportedPtr = &pfIndexingSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfIndexingSupportedPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetIndexing(WICJpegIndexingOptions options, uint horizontalIntervalSize) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, options, horizontalIntervalSize); + return ret; + } + + /// To be documented. + public readonly int ClearIndexing() + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAcHuffmanTable(uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTable) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, scanIndex, tableIndex, pAcHuffmanTable); + return ret; + } + + /// To be documented. + public readonly int GetAcHuffmanTable(uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegACHuffmanTable pAcHuffmanTable) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTablePtr = &pAcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, scanIndex, tableIndex, pAcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDcHuffmanTable(uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTable) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, scanIndex, tableIndex, pDcHuffmanTable); + return ret; + } + + /// To be documented. + public readonly int GetDcHuffmanTable(uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegDCHuffmanTable pDcHuffmanTable) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTablePtr = &pDcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, scanIndex, tableIndex, pDcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetQuantizationTable(uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTable) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, scanIndex, tableIndex, pQuantizationTable); + return ret; + } + + /// To be documented. + public readonly int GetQuantizationTable(uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegQuantizationTable pQuantizationTable) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTablePtr = &pQuantizationTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, scanIndex, tableIndex, pQuantizationTablePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFrameHeader(WICJpegFrameHeader* pFrameHeader) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeader); + return ret; + } + + /// To be documented. + public readonly int GetFrameHeader(ref WICJpegFrameHeader pFrameHeader) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICJpegFrameHeader* pFrameHeaderPtr = &pFrameHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetScanHeader(uint scanIndex, WICJpegScanHeader* pScanHeader) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeader); + return ret; + } + + /// To be documented. + public readonly int GetScanHeader(uint scanIndex, ref WICJpegScanHeader pScanHeader) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICJpegScanHeader* pScanHeaderPtr = &pScanHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, byte* pbScanData, uint* pcbScanDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanData, pcbScanDataActual); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, byte* pbScanData, ref uint pcbScanDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbScanDataActualPtr = &pcbScanDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanData, pcbScanDataActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, ref byte pbScanData, uint* pcbScanDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbScanDataPtr = &pbScanData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActual); + } + return ret; + } + + /// To be documented. + public readonly int CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, ref byte pbScanData, ref uint pcbScanDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbScanDataPtr = &pbScanData) + { + fixed (uint* pcbScanDataActualPtr = &pcbScanDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData, uint* pcbScanDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbScanDataPtr = (byte*) SilkMarshal.StringToPtr(pbScanData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActual); + SilkMarshal.Free((nint)pbScanDataPtr); + return ret; + } + + /// To be documented. + public readonly int CopyScan(uint scanIndex, uint scanOffset, uint cbScanData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData, ref uint pcbScanDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbScanDataPtr = (byte*) SilkMarshal.StringToPtr(pbScanData, NativeStringEncoding.UTF8); + fixed (uint* pcbScanDataActualPtr = &pcbScanDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActualPtr); + } + SilkMarshal.Free((nint)pbScanDataPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyMinimalStream(uint streamOffset, uint cbStreamData, byte* pbStreamData, uint* pcbStreamDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamData, pcbStreamDataActual); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyMinimalStream(uint streamOffset, uint cbStreamData, byte* pbStreamData, ref uint pcbStreamDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbStreamDataActualPtr = &pcbStreamDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamData, pcbStreamDataActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyMinimalStream(uint streamOffset, uint cbStreamData, ref byte pbStreamData, uint* pcbStreamDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbStreamDataPtr = &pbStreamData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActual); + } + return ret; + } + + /// To be documented. + public readonly int CopyMinimalStream(uint streamOffset, uint cbStreamData, ref byte pbStreamData, ref uint pcbStreamDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbStreamDataPtr = &pbStreamData) + { + fixed (uint* pcbStreamDataActualPtr = &pcbStreamDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyMinimalStream(uint streamOffset, uint cbStreamData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbStreamData, uint* pcbStreamDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbStreamDataPtr = (byte*) SilkMarshal.StringToPtr(pbStreamData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActual); + SilkMarshal.Free((nint)pbStreamDataPtr); + return ret; + } + + /// To be documented. + public readonly int CopyMinimalStream(uint streamOffset, uint cbStreamData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbStreamData, ref uint pcbStreamDataActual) + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbStreamDataPtr = (byte*) SilkMarshal.StringToPtr(pbStreamData, NativeStringEncoding.UTF8); + fixed (uint* pcbStreamDataActualPtr = &pcbStreamDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActualPtr); + } + SilkMarshal.Free((nint)pbStreamDataPtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameEncode.gen.cs new file mode 100644 index 0000000000..202be958e2 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameEncode.gen.cs @@ -0,0 +1,227 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("2f0c601f-d2c6-468c-abfa-49495d983ed1")] + [NativeName("Name", "IWICJpegFrameEncode")] + public unsafe partial struct IWICJpegFrameEncode : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("2f0c601f-d2c6-468c-abfa-49495d983ed1"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICJpegFrameEncode val) + => Unsafe.As(ref val); + + public IWICJpegFrameEncode + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAcHuffmanTable(uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTable) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, scanIndex, tableIndex, pAcHuffmanTable); + return ret; + } + + /// To be documented. + public readonly int GetAcHuffmanTable(uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegACHuffmanTable pAcHuffmanTable) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTablePtr = &pAcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, scanIndex, tableIndex, pAcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDcHuffmanTable(uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTable) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, scanIndex, tableIndex, pDcHuffmanTable); + return ret; + } + + /// To be documented. + public readonly int GetDcHuffmanTable(uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegDCHuffmanTable pDcHuffmanTable) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTablePtr = &pDcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, scanIndex, tableIndex, pDcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetQuantizationTable(uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTable) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, scanIndex, tableIndex, pQuantizationTable); + return ret; + } + + /// To be documented. + public readonly int GetQuantizationTable(uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegQuantizationTable pQuantizationTable) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTablePtr = &pQuantizationTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, scanIndex, tableIndex, pQuantizationTablePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteScan(uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pbScanData) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cbScanData, pbScanData); + return ret; + } + + /// To be documented. + public readonly int WriteScan(uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pbScanData) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbScanDataPtr = &pbScanData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cbScanData, pbScanDataPtr); + } + return ret; + } + + /// To be documented. + public readonly int WriteScan(uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData) + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbScanDataPtr = (byte*) SilkMarshal.StringToPtr(pbScanData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cbScanData, pbScanDataPtr); + SilkMarshal.Free((nint)pbScanDataPtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICJpegFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockReader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockReader.gen.cs new file mode 100644 index 0000000000..f9417020b1 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockReader.gen.cs @@ -0,0 +1,224 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("feaa2a8d-b3f3-43e4-b25c-d1de990a1ae1")] + [NativeName("Name", "IWICMetadataBlockReader")] + public unsafe partial struct IWICMetadataBlockReader : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("feaa2a8d-b3f3-43e4-b25c-d1de990a1ae1"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataBlockReader val) + => Unsafe.As(ref val); + + public IWICMetadataBlockReader + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCount(uint* pcCount) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCount); + return ret; + } + + /// To be documented. + public readonly int GetCount(ref uint pcCount) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetReaderByIndex(uint nIndex, IWICMetadataReader** ppIMetadataReader) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReader); + return ret; + } + + /// To be documented. + public readonly unsafe int GetReaderByIndex(uint nIndex, ref IWICMetadataReader* ppIMetadataReader) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader** ppIMetadataReaderPtr = &ppIMetadataReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadata) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumMetadata) + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetReaderByIndex(uint nIndex, ref ComPtr ppIMetadataReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetReaderByIndex(nIndex, (IWICMetadataReader**) ppIMetadataReader.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataBlockReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockWriter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockWriter.gen.cs new file mode 100644 index 0000000000..df1ec095cc --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataBlockWriter.gen.cs @@ -0,0 +1,352 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("08fb9676-b444-41e8-8dbe-6a53a542bff1")] + [NativeName("Name", "IWICMetadataBlockWriter")] + public unsafe partial struct IWICMetadataBlockWriter : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("08fb9676-b444-41e8-8dbe-6a53a542bff1"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICMetadataBlockReader(IWICMetadataBlockWriter val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataBlockWriter val) + => Unsafe.As(ref val); + + public IWICMetadataBlockWriter + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCount(uint* pcCount) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCount); + return ret; + } + + /// To be documented. + public readonly int GetCount(ref uint pcCount) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetReaderByIndex(uint nIndex, IWICMetadataReader** ppIMetadataReader) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReader); + return ret; + } + + /// To be documented. + public readonly unsafe int GetReaderByIndex(uint nIndex, ref IWICMetadataReader* ppIMetadataReader) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader** ppIMetadataReaderPtr = &ppIMetadataReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadata) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumMetadata) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromBlockReader(IWICMetadataBlockReader* pIMDBlockReader) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIMDBlockReader); + return ret; + } + + /// To be documented. + public readonly int InitializeFromBlockReader(ref IWICMetadataBlockReader pIMDBlockReader) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataBlockReader* pIMDBlockReaderPtr = &pIMDBlockReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIMDBlockReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetWriterByIndex(uint nIndex, IWICMetadataWriter** ppIMetadataWriter) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, nIndex, ppIMetadataWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int GetWriterByIndex(uint nIndex, ref IWICMetadataWriter* ppIMetadataWriter) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataWriter** ppIMetadataWriterPtr = &ppIMetadataWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, nIndex, ppIMetadataWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int AddWriter(IWICMetadataWriter* pIMetadataWriter) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIMetadataWriter); + return ret; + } + + /// To be documented. + public readonly int AddWriter(ref IWICMetadataWriter pIMetadataWriter) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataWriter* pIMetadataWriterPtr = &pIMetadataWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIMetadataWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetWriterByIndex(uint nIndex, IWICMetadataWriter* pIMetadataWriter) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pIMetadataWriter); + return ret; + } + + /// To be documented. + public readonly int SetWriterByIndex(uint nIndex, ref IWICMetadataWriter pIMetadataWriter) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataWriter* pIMetadataWriterPtr = &pIMetadataWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pIMetadataWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly int RemoveWriterByIndex(uint nIndex) + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, nIndex); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetReaderByIndex(uint nIndex, ref ComPtr ppIMetadataReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetReaderByIndex(nIndex, (IWICMetadataReader**) ppIMetadataReader.GetAddressOf()); + } + + /// To be documented. + public readonly int InitializeFromBlockReader(ComPtr pIMDBlockReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->InitializeFromBlockReader((IWICMetadataBlockReader*) pIMDBlockReader.Handle); + } + + /// To be documented. + public readonly int GetWriterByIndex(uint nIndex, ref ComPtr ppIMetadataWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetWriterByIndex(nIndex, (IWICMetadataWriter**) ppIMetadataWriter.GetAddressOf()); + } + + /// To be documented. + public readonly int AddWriter(ComPtr pIMetadataWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->AddWriter((IWICMetadataWriter*) pIMetadataWriter.Handle); + } + + /// To be documented. + public readonly int SetWriterByIndex(uint nIndex, ComPtr pIMetadataWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SetWriterByIndex(nIndex, (IWICMetadataWriter*) pIMetadataWriter.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataBlockWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs new file mode 100644 index 0000000000..f26b632459 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs @@ -0,0 +1,789 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("aba958bf-c672-44d1-8d61-ce6df2e682c2")] + [NativeName("Name", "IWICMetadataHandlerInfo")] + public unsafe partial struct IWICMetadataHandlerInfo : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("aba958bf-c672-44d1-8d61-ce6df2e682c2"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICComponentInfo(IWICMetadataHandlerInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataHandlerInfo val) + => Unsafe.As(ref val); + + public IWICMetadataHandlerInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataFormat(Guid* pguidMetadataFormat) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public readonly int GetMetadataFormat(ref Guid pguidMetadataFormat) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, ref Guid pguidContainerFormats, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetContainerFormats(uint cContainerFormats, ref Guid pguidContainerFormats, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesRequireFullStream(int* pfRequiresFullStream) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStream); + return ret; + } + + /// To be documented. + public readonly int DoesRequireFullStream(ref int pfRequiresFullStream) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfRequiresFullStreamPtr = &pfRequiresFullStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportPadding(int* pfSupportsPadding) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPadding); + return ret; + } + + /// To be documented. + public readonly int DoesSupportPadding(ref int pfSupportsPadding) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportsPaddingPtr = &pfSupportsPadding) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPaddingPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesRequireFixedSize(int* pfFixedSize) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSize); + return ret; + } + + /// To be documented. + public readonly int DoesRequireFixedSize(ref int pfFixedSize) + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfFixedSizePtr = &pfFixedSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSizePtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs new file mode 100644 index 0000000000..8e23391c4f --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryReader.gen.cs @@ -0,0 +1,320 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("30989668-e1c9-4597-b395-458eedb808df")] + [NativeName("Name", "IWICMetadataQueryReader")] + public unsafe partial struct IWICMetadataQueryReader : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("30989668-e1c9-4597-b395-458eedb808df"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataQueryReader val) + => Unsafe.As(ref val); + + public IWICMetadataQueryReader + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, char* wzNamespace, uint* pcchActualLength) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLength); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, char* wzNamespace, ref uint pcchActualLength) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLengthPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, ref char wzNamespace, uint* pcchActualLength) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + } + return ret; + } + + /// To be documented. + public readonly int GetLocation(uint cchMaxLength, ref char wzNamespace, ref uint pcchActualLength) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, uint* pcchActualLength) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public readonly int GetLocation(uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, ref uint pcchActualLength) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, void* pvarValue) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(Silk.NET.Core.Win32Extras.IEnumString** ppIEnumString) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(ref Silk.NET.Core.Win32Extras.IEnumString* ppIEnumString) + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumString** ppIEnumStringPtr = &ppIEnumString) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumStringPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataQueryReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs new file mode 100644 index 0000000000..38ffde70f2 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataQueryWriter.gen.cs @@ -0,0 +1,428 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("a721791a-0def-4d06-bd91-2118bf1db10b")] + [NativeName("Name", "IWICMetadataQueryWriter")] + public unsafe partial struct IWICMetadataQueryWriter : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a721791a-0def-4d06-bd91-2118bf1db10b"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICMetadataQueryReader(IWICMetadataQueryWriter val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataQueryWriter val) + => Unsafe.As(ref val); + + public IWICMetadataQueryWriter + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormat(Guid* pguidContainerFormat) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public readonly int GetContainerFormat(ref Guid pguidContainerFormat) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, char* wzNamespace, uint* pcchActualLength) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLength); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, char* wzNamespace, ref uint pcchActualLength) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLengthPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, ref char wzNamespace, uint* pcchActualLength) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + } + return ret; + } + + /// To be documented. + public readonly int GetLocation(uint cchMaxLength, ref char wzNamespace, ref uint pcchActualLength) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetLocation(uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, uint* pcchActualLength) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public readonly int GetLocation(uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, ref uint pcchActualLength) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, void* pvarValue) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(Silk.NET.Core.Win32Extras.IEnumString** ppIEnumString) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumString); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(ref Silk.NET.Core.Win32Extras.IEnumString* ppIEnumString) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumString** ppIEnumStringPtr = &ppIEnumString) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumStringPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly int SetMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + } + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int RemoveMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, wzName); + return ret; + } + + /// To be documented. + public readonly int RemoveMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, wzNamePtr); + } + return ret; + } + + /// To be documented. + public readonly int RemoveMetadataByName([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName) + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, wzNamePtr); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataQueryWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs new file mode 100644 index 0000000000..9efc21e730 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReader.gen.cs @@ -0,0 +1,448 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("9204fe99-d8fc-4fd5-a001-9536b067a899")] + [NativeName("Name", "IWICMetadataReader")] + public unsafe partial struct IWICMetadataReader : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("9204fe99-d8fc-4fd5-a001-9536b067a899"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataReader val) + => Unsafe.As(ref val); + + public IWICMetadataReader + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataFormat(Guid* pguidMetadataFormat) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public readonly int GetMetadataFormat(ref Guid pguidMetadataFormat) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataHandlerInfo(IWICMetadataHandlerInfo** ppIHandler) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandler); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataHandlerInfo(ref IWICMetadataHandlerInfo* ppIHandler) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataHandlerInfo** ppIHandlerPtr = &ppIHandler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandlerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCount(uint* pcCount) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCount); + return ret; + } + + /// To be documented. + public readonly int GetCount(ref uint pcCount) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public readonly int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public readonly int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(IWICEnumMetadataItem** ppIEnumMetadata) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(ref IWICEnumMetadataItem* ppIEnumMetadata) + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICEnumMetadataItem** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetMetadataHandlerInfo(ref ComPtr ppIHandler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataHandlerInfo((IWICMetadataHandlerInfo**) ppIHandler.GetAddressOf()); + } + + /// To be documented. + public readonly int GetEnumerator(ref ComPtr ppIEnumMetadata) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetEnumerator((IWICEnumMetadataItem**) ppIEnumMetadata.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataReader*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs new file mode 100644 index 0000000000..48d7fd469a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs @@ -0,0 +1,1201 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("eebf1f5b-07c1-4447-a3ab-22acaf78a804")] + [NativeName("Name", "IWICMetadataReaderInfo")] + public unsafe partial struct IWICMetadataReaderInfo : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("eebf1f5b-07c1-4447-a3ab-22acaf78a804"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICMetadataHandlerInfo(IWICMetadataReaderInfo val) + => Unsafe.As(ref val); + + public static implicit operator IWICComponentInfo(IWICMetadataReaderInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataReaderInfo val) + => Unsafe.As(ref val); + + public IWICMetadataReaderInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataFormat(Guid* pguidMetadataFormat) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public readonly int GetMetadataFormat(ref Guid pguidMetadataFormat) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, ref Guid pguidContainerFormats, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetContainerFormats(uint cContainerFormats, ref Guid pguidContainerFormats, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesRequireFullStream(int* pfRequiresFullStream) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStream); + return ret; + } + + /// To be documented. + public readonly int DoesRequireFullStream(ref int pfRequiresFullStream) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfRequiresFullStreamPtr = &pfRequiresFullStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportPadding(int* pfSupportsPadding) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPadding); + return ret; + } + + /// To be documented. + public readonly int DoesSupportPadding(ref int pfSupportsPadding) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportsPaddingPtr = &pfSupportsPadding) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPaddingPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesRequireFixedSize(int* pfFixedSize) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSize); + return ret; + } + + /// To be documented. + public readonly int DoesRequireFixedSize(ref int pfFixedSize) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfFixedSizePtr = &pfFixedSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActual); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActual); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActual); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActual); + } + } + } + return ret; + } + + /// To be documented. + public readonly int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Guid* guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStream, pfMatches); + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Guid* guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, ref int pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStream, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Guid* guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, int* pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStreamPtr, pfMatches); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Guid* guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref int pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStreamPtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(ref Guid guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStream, pfMatches); + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(ref Guid guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, ref int pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStream, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int MatchesPattern(ref Guid guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, int* pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStreamPtr, pfMatches); + } + } + return ret; + } + + /// To be documented. + public readonly int MatchesPattern(ref Guid guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref int pfMatches) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStreamPtr, pfMatchesPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(IWICMetadataReader** ppIReader) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, ppIReader); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref IWICMetadataReader* ppIReader) + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, ppIReaderPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Guid* guidContainerFormat, ComPtr pIStream, int* pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MatchesPattern(guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pfMatches); + } + + /// To be documented. + public readonly unsafe int MatchesPattern(Guid* guidContainerFormat, ComPtr pIStream, ref int pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MatchesPattern(guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pfMatches); + } + + /// To be documented. + public readonly unsafe int MatchesPattern(ref Guid guidContainerFormat, ComPtr pIStream, int* pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MatchesPattern(ref guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pfMatches); + } + + /// To be documented. + public readonly int MatchesPattern(ref Guid guidContainerFormat, ComPtr pIStream, ref int pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->MatchesPattern(ref guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pfMatches); + } + + /// To be documented. + public readonly int CreateInstance(ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs new file mode 100644 index 0000000000..01ff8a9062 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriter.gen.cs @@ -0,0 +1,724 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("f7836e16-3be0-470b-86bb-160d0aecd7de")] + [NativeName("Name", "IWICMetadataWriter")] + public unsafe partial struct IWICMetadataWriter : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("f7836e16-3be0-470b-86bb-160d0aecd7de"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICMetadataReader(IWICMetadataWriter val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataWriter val) + => Unsafe.As(ref val); + + public IWICMetadataWriter + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataFormat(Guid* pguidMetadataFormat) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public readonly int GetMetadataFormat(ref Guid pguidMetadataFormat) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataHandlerInfo(IWICMetadataHandlerInfo** ppIHandler) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandler); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataHandlerInfo(ref IWICMetadataHandlerInfo* ppIHandler) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataHandlerInfo** ppIHandlerPtr = &ppIHandler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandlerPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCount(uint* pcCount) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCount); + return ret; + } + + /// To be documented. + public readonly int GetCount(ref uint pcCount) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public readonly int GetValueByIndex(uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public readonly int GetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(IWICEnumMetadataItem** ppIEnumMetadata) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public readonly unsafe int GetEnumerator(ref IWICEnumMetadataItem* ppIEnumMetadata) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICEnumMetadataItem** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public readonly int SetValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public readonly int SetValueByIndex(uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarId); + return ret; + } + + /// To be documented. + public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarIdPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) where T0 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarId); + } + return ret; + } + + /// To be documented. + public readonly int RemoveValue([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId) where T0 : unmanaged where T1 : unmanaged + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarIdPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int RemoveValueByIndex(uint nIndex) + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, nIndex); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetMetadataHandlerInfo(ref ComPtr ppIHandler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetMetadataHandlerInfo((IWICMetadataHandlerInfo**) ppIHandler.GetAddressOf()); + } + + /// To be documented. + public readonly int GetEnumerator(ref ComPtr ppIEnumMetadata) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetEnumerator((IWICEnumMetadataItem**) ppIEnumMetadata.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataWriter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs new file mode 100644 index 0000000000..d2341adb5c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs @@ -0,0 +1,929 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("b22e3fba-3925-4323-b5c1-9ebfc430f236")] + [NativeName("Name", "IWICMetadataWriterInfo")] + public unsafe partial struct IWICMetadataWriterInfo : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("b22e3fba-3925-4323-b5c1-9ebfc430f236"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICMetadataHandlerInfo(IWICMetadataWriterInfo val) + => Unsafe.As(ref val); + + public static implicit operator IWICComponentInfo(IWICMetadataWriterInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICMetadataWriterInfo val) + => Unsafe.As(ref val); + + public IWICMetadataWriterInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetMetadataFormat(Guid* pguidMetadataFormat) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public readonly int GetMetadataFormat(ref Guid pguidMetadataFormat) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, Guid* pguidContainerFormats, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetContainerFormats(uint cContainerFormats, ref Guid pguidContainerFormats, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetContainerFormats(uint cContainerFormats, ref Guid pguidContainerFormats, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceManufacturer(uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly int GetDeviceModels(uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesRequireFullStream(int* pfRequiresFullStream) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStream); + return ret; + } + + /// To be documented. + public readonly int DoesRequireFullStream(ref int pfRequiresFullStream) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfRequiresFullStreamPtr = &pfRequiresFullStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportPadding(int* pfSupportsPadding) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPadding); + return ret; + } + + /// To be documented. + public readonly int DoesSupportPadding(ref int pfSupportsPadding) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportsPaddingPtr = &pfSupportsPadding) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPaddingPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesRequireFixedSize(int* pfFixedSize) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSize); + return ret; + } + + /// To be documented. + public readonly int DoesRequireFixedSize(ref int pfFixedSize) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfFixedSizePtr = &pfFixedSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActual); + } + } + return ret; + } + + /// To be documented. + public readonly int GetHeader(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(IWICMetadataWriter** ppIWriter) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, ppIWriter); + return ret; + } + + /// To be documented. + public readonly unsafe int CreateInstance(ref IWICMetadataWriter* ppIWriter) + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, ppIWriterPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CreateInstance(ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CreateInstance((IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs new file mode 100644 index 0000000000..3f306f6a63 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs @@ -0,0 +1,373 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00000040-a8f2-4877-ba0a-fd2b6645fb94")] + [NativeName("Name", "IWICPalette")] + public unsafe partial struct IWICPalette : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00000040-a8f2-4877-ba0a-fd2b6645fb94"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPalette val) + => Unsafe.As(ref val); + + public IWICPalette + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int InitializePredefined(WICBitmapPaletteType ePaletteType, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ePaletteType, fAddTransparentColor); + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeCustom(uint* pColors, uint cCount) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pColors, cCount); + return ret; + } + + /// To be documented. + public readonly int InitializeCustom(ref uint pColors, uint cCount) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pColorsPtr = &pColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pColorsPtr, cCount); + } + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromBitmap(IWICBitmapSource* pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pISurface, cCount, fAddTransparentColor); + return ret; + } + + /// To be documented. + public readonly int InitializeFromBitmap(ref IWICBitmapSource pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource* pISurfacePtr = &pISurface) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pISurfacePtr, cCount, fAddTransparentColor); + } + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromPalette(IWICPalette* pIPalette) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int InitializeFromPalette(ref IWICPalette pIPalette) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetType(WICBitmapPaletteType* pePaletteType) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteType); + return ret; + } + + /// To be documented. + public readonly int GetType(ref WICBitmapPaletteType pePaletteType) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPaletteType* pePaletteTypePtr = &pePaletteType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorCount(uint* pcCount) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pcCount); + return ret; + } + + /// To be documented. + public readonly int GetColorCount(ref uint pcCount) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColors(uint cCount, uint* pColors, uint* pcActualColors) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColors, pcActualColors); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColors(uint cCount, uint* pColors, ref uint pcActualColors) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcActualColorsPtr = &pcActualColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColors, pcActualColorsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColors(uint cCount, ref uint pColors, uint* pcActualColors) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pColorsPtr = &pColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColorsPtr, pcActualColors); + } + return ret; + } + + /// To be documented. + public readonly int GetColors(uint cCount, ref uint pColors, ref uint pcActualColors) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pColorsPtr = &pColors) + { + fixed (uint* pcActualColorsPtr = &pcActualColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColorsPtr, pcActualColorsPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsBlackWhite(int* pfIsBlackWhite) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, pfIsBlackWhite); + return ret; + } + + /// To be documented. + public readonly int IsBlackWhite(ref int pfIsBlackWhite) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfIsBlackWhitePtr = &pfIsBlackWhite) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, pfIsBlackWhitePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int IsGrayscale(int* pfIsGrayscale) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pfIsGrayscale); + return ret; + } + + /// To be documented. + public readonly int IsGrayscale(ref int pfIsGrayscale) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfIsGrayscalePtr = &pfIsGrayscale) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pfIsGrayscalePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int HasAlpha(int* pfHasAlpha) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pfHasAlpha); + return ret; + } + + /// To be documented. + public readonly int HasAlpha(ref int pfHasAlpha) + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfHasAlphaPtr = &pfHasAlpha) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pfHasAlphaPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int InitializeFromBitmap(ComPtr pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->InitializeFromBitmap((IWICBitmapSource*) pISurface.Handle, cCount, fAddTransparentColor); + } + + /// To be documented. + public readonly int InitializeFromPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->InitializeFromPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPersistStream.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPersistStream.gen.cs new file mode 100644 index 0000000000..ffc3e22973 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPersistStream.gen.cs @@ -0,0 +1,340 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("00675040-6908-45f8-86a3-49c7dfd6d9ad")] + [NativeName("Name", "IWICPersistStream")] + public unsafe partial struct IWICPersistStream : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("00675040-6908-45f8-86a3-49c7dfd6d9ad"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Win32Extras.IPersistStream(IWICPersistStream val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Win32Extras.IPersist(IWICPersistStream val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPersistStream val) + => Unsafe.As(ref val); + + public IWICPersistStream + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetClassID(Guid* pClassID) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public readonly int GetClassID(ref Guid pClassID) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public readonly int IsDirty() + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Load(Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public readonly int Load(ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Save(Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public readonly int Save(ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSizeMax(ulong* pcbSize) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pcbSize); + return ret; + } + + /// To be documented. + public readonly int GetSizeMax(ref ulong pcbSize) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadEx(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStream, pguidPreferredVendor, dwPersistOptions); + return ret; + } + + /// To be documented. + public readonly unsafe int LoadEx(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidPreferredVendor, uint dwPersistOptions) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPreferredVendorPtr = &pguidPreferredVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStream, pguidPreferredVendorPtr, dwPersistOptions); + } + return ret; + } + + /// To be documented. + public readonly unsafe int LoadEx(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStreamPtr, pguidPreferredVendor, dwPersistOptions); + } + return ret; + } + + /// To be documented. + public readonly int LoadEx(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidPreferredVendor, uint dwPersistOptions) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidPreferredVendorPtr = &pguidPreferredVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStreamPtr, pguidPreferredVendorPtr, dwPersistOptions); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int SaveEx(Silk.NET.Core.Win32Extras.IStream* pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIStream, dwPersistOptions, fClearDirty); + return ret; + } + + /// To be documented. + public readonly int SaveEx(ref Silk.NET.Core.Win32Extras.IStream pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIStreamPtr, dwPersistOptions, fClearDirty); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int Load(ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public readonly int Save(ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public readonly unsafe int LoadEx(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadEx((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidPreferredVendor, dwPersistOptions); + } + + /// To be documented. + public readonly int LoadEx(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidPreferredVendor, uint dwPersistOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->LoadEx((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidPreferredVendor, dwPersistOptions); + } + + /// To be documented. + public readonly int SaveEx(ComPtr pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->SaveEx((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, dwPersistOptions, fClearDirty); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPersistStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs new file mode 100644 index 0000000000..eb6cefe49c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs @@ -0,0 +1,676 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("e8eda601-3d48-431a-ab44-69059be88bbe")] + [NativeName("Name", "IWICPixelFormatInfo")] + public unsafe partial struct IWICPixelFormatInfo : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("e8eda601-3d48-431a-ab44-69059be88bbe"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICComponentInfo(IWICPixelFormatInfo val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPixelFormatInfo val) + => Unsafe.As(ref val); + + public IWICPixelFormatInfo + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFormatGUID(Guid* pFormat) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormat); + return ret; + } + + /// To be documented. + public readonly int GetFormatGUID(ref Guid pFormat) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pFormatPtr = &pFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContext(IWICColorContext** ppIColorContext) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContext(ref IWICColorContext* ppIColorContext) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetBitsPerPixel(uint* puiBitsPerPixel) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixel); + return ret; + } + + /// To be documented. + public readonly int GetBitsPerPixel(ref uint puiBitsPerPixel) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiBitsPerPixelPtr = &puiBitsPerPixel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixelPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelCount(uint* puiChannelCount) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCount); + return ret; + } + + /// To be documented. + public readonly int GetChannelCount(ref uint puiChannelCount) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiChannelCountPtr = &puiChannelCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, uint* pcbActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, ref uint pcbActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, uint* pcbActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, ref uint pcbActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, uint* pcbActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public readonly int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, ref uint pcbActual) + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetColorContext(ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContext((IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs new file mode 100644 index 0000000000..6ed29c5a20 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs @@ -0,0 +1,721 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("a9db33a2-af5f-43c7-b679-74f5984b5aa4")] + [NativeName("Name", "IWICPixelFormatInfo2")] + public unsafe partial struct IWICPixelFormatInfo2 : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("a9db33a2-af5f-43c7-b679-74f5984b5aa4"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICPixelFormatInfo(IWICPixelFormatInfo2 val) + => Unsafe.As(ref val); + + public static implicit operator IWICComponentInfo(IWICPixelFormatInfo2 val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPixelFormatInfo2 val) + => Unsafe.As(ref val); + + public IWICPixelFormatInfo2 + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetComponentType(WICComponentType* pType) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public readonly int GetComponentType(ref WICComponentType pType) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCLSID(Guid* pclsid) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public readonly int GetCLSID(ref Guid pclsid) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSigningStatus(uint* pStatus) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public readonly int GetSigningStatus(ref uint pStatus) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly int GetAuthor(uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVendorGUID(Guid* pguidVendor) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public readonly int GetVendorGUID(ref Guid pguidVendor) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetVersion(uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly int GetSpecVersion(uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly int GetFriendlyName(uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int GetFormatGUID(Guid* pFormat) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormat); + return ret; + } + + /// To be documented. + public readonly int GetFormatGUID(ref Guid pFormat) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pFormatPtr = &pFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContext(IWICColorContext** ppIColorContext) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContext); + return ret; + } + + /// To be documented. + public readonly unsafe int GetColorContext(ref IWICColorContext* ppIColorContext) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetBitsPerPixel(uint* puiBitsPerPixel) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixel); + return ret; + } + + /// To be documented. + public readonly int GetBitsPerPixel(ref uint puiBitsPerPixel) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiBitsPerPixelPtr = &puiBitsPerPixel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixelPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelCount(uint* puiChannelCount) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCount); + return ret; + } + + /// To be documented. + public readonly int GetChannelCount(ref uint puiChannelCount) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiChannelCountPtr = &puiChannelCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCountPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, uint* pcbActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual); + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, ref uint pcbActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, uint* pcbActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public readonly int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, ref uint pcbActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, uint* pcbActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public readonly int GetChannelMask(uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, ref uint pcbActual) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int SupportsTransparency(int* pfSupportsTransparency) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsTransparency); + return ret; + } + + /// To be documented. + public readonly int SupportsTransparency(ref int pfSupportsTransparency) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfSupportsTransparencyPtr = &pfSupportsTransparency) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsTransparencyPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetNumericRepresentation(WICPixelFormatNumericRepresentation* pNumericRepresentation) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentation); + return ret; + } + + /// To be documented. + public readonly int GetNumericRepresentation(ref WICPixelFormatNumericRepresentation pNumericRepresentation) + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICPixelFormatNumericRepresentation* pNumericRepresentationPtr = &pNumericRepresentation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentationPtr); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetColorContext(ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetColorContext((IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs new file mode 100644 index 0000000000..05b08cdd28 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs @@ -0,0 +1,217 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("f928b7b8-2221-40c1-b72e-7e82f1974d1a")] + [NativeName("Name", "IWICPlanarBitmapFrameEncode")] + public unsafe partial struct IWICPlanarBitmapFrameEncode : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("f928b7b8-2221-40c1-b72e-7e82f1974d1a"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPlanarBitmapFrameEncode val) + => Unsafe.As(ref val); + + public IWICPlanarBitmapFrameEncode + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int WritePixels(uint lineCount, WICBitmapPlane* pPlanes, uint cPlanes) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanes, cPlanes); + return ret; + } + + /// To be documented. + public readonly int WritePixels(uint lineCount, ref WICBitmapPlane pPlanes, uint cPlanes) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPlane* pPlanesPtr = &pPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanesPtr, cPlanes); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, WICRect* prcSource) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, ref WICRect prcSource) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcSourcePtr = &prcSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, WICRect* prcSource) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); + } + return ret; + } + + /// To be documented. + public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref WICRect prcSource) + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (WICRect* prcSourcePtr = &prcSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlanes, WICRect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, prcSource); + } + + /// To be documented. + public readonly int WriteSource(ref ComPtr ppPlanes, uint cPlanes, ref WICRect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, ref prcSource); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs new file mode 100644 index 0000000000..cc2e828d14 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs @@ -0,0 +1,708 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("3aff9cce-be95-4303-b927-e7d16ff4a613")] + [NativeName("Name", "IWICPlanarBitmapSourceTransform")] + public unsafe partial struct IWICPlanarBitmapSourceTransform : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("3aff9cce-be95-4303-b927-e7d16ff4a613"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPlanarBitmapSourceTransform val) + => Unsafe.As(ref val); + + public IWICPlanarBitmapSourceTransform + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + } + return ret; + } + + /// To be documented. + public readonly int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcSourcePtr = &prcSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcSourcePtr = &prcSource) + { + fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs new file mode 100644 index 0000000000..c5a940566b --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs @@ -0,0 +1,618 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("bebee9cb-83b0-4dcc-8132-b0aaa55eac96")] + [NativeName("Name", "IWICPlanarFormatConverter")] + public unsafe partial struct IWICPlanarFormatConverter : IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("bebee9cb-83b0-4dcc-8132-b0aaa55eac96"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator IWICBitmapSource(IWICPlanarFormatConverter val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICPlanarFormatConverter val) + => Unsafe.As(ref val); + + public IWICPlanarFormatConverter + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, uint* puiHeight) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(uint* puiWidth, ref uint puiHeight) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetSize(ref uint puiWidth, uint* puiHeight) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public readonly int GetSize(ref uint puiWidth, ref uint puiHeight) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPixelFormat(Guid* pPixelFormat) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public readonly int GetPixelFormat(ref Guid pPixelFormat) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, double* pDpiY) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(double* pDpiX, ref double pDpiY) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetResolution(ref double pDpiX, double* pDpiY) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public readonly int GetResolution(ref double pDpiX, ref double pDpiY) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPalette(IWICPalette* pIPalette) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public readonly int CopyPalette(ref IWICPalette pIPalette) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormat, pfCanConvert); + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormat, pfCanConvertPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormatPtr, pfCanConvert); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormatPtr, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormat, pfCanConvert); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormat, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormatPtr, pfCanConvert); + } + } + return ret; + } + + /// To be documented. + public readonly int CanConvert([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormatPtr, pfCanConvertPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, ref dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref ppPlanes, cPlanes, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Initialize(ref ppPlanes, cPlanes, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs new file mode 100644 index 0000000000..3639e505ae --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs @@ -0,0 +1,141 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("4776f9cd-9517-45fa-bf24-e89c5ec5c60c")] + [NativeName("Name", "IWICProgressCallback")] + public unsafe partial struct IWICProgressCallback : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("4776f9cd-9517-45fa-bf24-e89c5ec5c60c"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICProgressCallback val) + => Unsafe.As(ref val); + + public IWICProgressCallback + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly int Notify(uint uFrameNum, WICProgressOperation operation, double dblProgress) + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, uFrameNum, operation, dblProgress); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressiveLevelControl.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressiveLevelControl.gen.cs new file mode 100644 index 0000000000..295786e588 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressiveLevelControl.gen.cs @@ -0,0 +1,183 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("daac296f-7aa5-4dbf-8d15-225c5976f891")] + [NativeName("Name", "IWICProgressiveLevelControl")] + public unsafe partial struct IWICProgressiveLevelControl : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("daac296f-7aa5-4dbf-8d15-225c5976f891"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICProgressiveLevelControl val) + => Unsafe.As(ref val); + + public IWICProgressiveLevelControl + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetLevelCount(uint* pcLevels) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pcLevels); + return ret; + } + + /// To be documented. + public readonly int GetLevelCount(ref uint pcLevels) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcLevelsPtr = &pcLevels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pcLevelsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetCurrentLevel(uint* pnLevel) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pnLevel); + return ret; + } + + /// To be documented. + public readonly int GetCurrentLevel(ref uint pnLevel) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pnLevelPtr = &pnLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pnLevelPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetCurrentLevel(uint nLevel) + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nLevel); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICProgressiveLevelControl*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStream.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStream.gen.cs new file mode 100644 index 0000000000..b76e6df631 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStream.gen.cs @@ -0,0 +1,612 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("135ff860-22b7-4ddf-b0f6-218f4f299a43")] + [NativeName("Name", "IWICStream")] + public unsafe partial struct IWICStream : IComVtbl, IComVtbl, IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("135ff860-22b7-4ddf-b0f6-218f4f299a43"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Win32Extras.IStream(IWICStream val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Win32Extras.ISequentialStream(IWICStream val) + => Unsafe.As(ref val); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICStream val) + => Unsafe.As(ref val); + + public IWICStream + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int Read(void* pv, uint cb, uint* pcbRead) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pv, cb, pcbRead); + return ret; + } + + /// To be documented. + public readonly unsafe int Read(void* pv, uint cb, ref uint pcbRead) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pv, cb, pcbReadPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Read(ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pvPtr, cb, pcbRead); + } + return ret; + } + + /// To be documented. + public readonly int Read(ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pvPtr, cb, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly int Write([Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int Seek(long dlibMove, uint dwOrigin, ulong* plibNewPosition) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, dlibMove, dwOrigin, plibNewPosition); + return ret; + } + + /// To be documented. + public readonly int Seek(long dlibMove, uint dwOrigin, ref ulong plibNewPosition) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* plibNewPositionPtr = &plibNewPosition) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, dlibMove, dwOrigin, plibNewPositionPtr); + } + return ret; + } + + /// To be documented. + public readonly int SetSize(ulong libNewSize) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, libNewSize); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbRead, pcbWritten); + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbRead, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbReadPtr, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (ulong* pcbReadPtr = &pcbRead) + { + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbReadPtr, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbRead, pcbWritten); + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbRead, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public readonly unsafe int CopyTo(ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + fixed (ulong* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbReadPtr, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public readonly int CopyTo(ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + fixed (ulong* pcbReadPtr = &pcbRead) + { + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbReadPtr, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public readonly int Commit(uint grfCommitFlags) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, grfCommitFlags); + return ret; + } + + /// To be documented. + public readonly int Revert() + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this); + return ret; + } + + /// To be documented. + public readonly int LockRegion(ulong libOffset, ulong cb, uint dwLockType) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public readonly int UnlockRegion(ulong libOffset, ulong cb, uint dwLockType) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public readonly unsafe int Stat(Silk.NET.Core.Win32Extras.STATSTG* pstatstg, uint grfStatFlag) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pstatstg, grfStatFlag); + return ret; + } + + /// To be documented. + public readonly int Stat(ref Silk.NET.Core.Win32Extras.STATSTG pstatstg, uint grfStatFlag) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.STATSTG* pstatstgPtr = &pstatstg) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pstatstgPtr, grfStatFlag); + } + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppstm); + return ret; + } + + /// To be documented. + public readonly unsafe int Clone(ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppstmPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromIStream(Silk.NET.Core.Win32Extras.IStream* pIStream) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, pIStream); + return ret; + } + + /// To be documented. + public readonly int InitializeFromIStream(ref Silk.NET.Core.Win32Extras.IStream pIStream) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, pIStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFileName, uint dwDesiredAccess) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, wzFileName, dwDesiredAccess); + return ret; + } + + /// To be documented. + public readonly int InitializeFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFileName, uint dwDesiredAccess) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (char* wzFileNamePtr = &wzFileName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, wzFileNamePtr, dwDesiredAccess); + } + return ret; + } + + /// To be documented. + public readonly int InitializeFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFileName, uint dwDesiredAccess) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var wzFileNamePtr = (byte*) SilkMarshal.StringToPtr(wzFileName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, wzFileNamePtr, dwDesiredAccess); + SilkMarshal.Free((nint)wzFileNamePtr); + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromMemory(byte* pbBuffer, uint cbBufferSize) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pbBuffer, cbBufferSize); + return ret; + } + + /// To be documented. + public readonly int InitializeFromMemory(ref byte pbBuffer, uint cbBufferSize) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pbBufferPtr, cbBufferSize); + } + return ret; + } + + /// To be documented. + public readonly int InitializeFromMemory([UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, uint cbBufferSize) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pbBufferPtr, cbBufferSize); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public readonly unsafe int InitializeFromIStreamRegion(Silk.NET.Core.Win32Extras.IStream* pIStream, ulong ulOffset, ulong ulMaxSize) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pIStream, ulOffset, ulMaxSize); + return ret; + } + + /// To be documented. + public readonly int InitializeFromIStreamRegion(ref Silk.NET.Core.Win32Extras.IStream pIStream, ulong ulOffset, ulong ulMaxSize) + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pIStreamPtr, ulOffset, ulMaxSize); + } + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly unsafe int CopyTo(ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + public readonly unsafe int CopyTo(ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + public readonly unsafe int CopyTo(ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + public readonly int CopyTo(ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + public readonly int Clone(ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->Clone((Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public readonly int InitializeFromIStream(ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->InitializeFromIStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + } + + /// To be documented. + public readonly int InitializeFromIStreamRegion(ComPtr pIStream, ulong ulOffset, ulong ulMaxSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->InitializeFromIStreamRegion((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ulOffset, ulMaxSize); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICStream*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStreamProvider.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStreamProvider.gen.cs new file mode 100644 index 0000000000..b7e71520d5 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICStreamProvider.gen.cs @@ -0,0 +1,212 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [Guid("449494bc-b468-4927-96d7-ba90d31ab505")] + [NativeName("Name", "IWICStreamProvider")] + public unsafe partial struct IWICStreamProvider : IComVtbl, IComVtbl + { + public static readonly Guid Guid = new("449494bc-b468-4927-96d7-ba90d31ab505"); + + void*** IComVtbl.AsVtblPtr() + => (void***) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + + public static implicit operator Silk.NET.Core.Native.IUnknown(IWICStreamProvider val) + => Unsafe.As(ref val); + + public IWICStreamProvider + ( + void** lpVtbl = null + ) : this() + { + if (lpVtbl is not null) + { + LpVtbl = lpVtbl; + } + } + + + [NativeName("Type", "")] + [NativeName("Type.Name", "")] + [NativeName("Name", "lpVtbl")] + public void** LpVtbl; + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, void** ppvObject) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(Guid* riid, ref void* ppvObject) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, void** ppvObject) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public readonly unsafe int QueryInterface(ref Guid riid, ref void* ppvObject) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public readonly uint AddRef() + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public readonly uint Release() + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public readonly unsafe int GetStream(Silk.NET.Core.Win32Extras.IStream** ppIStream) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ppIStream); + return ret; + } + + /// To be documented. + public readonly unsafe int GetStream(ref Silk.NET.Core.Win32Extras.IStream* ppIStream) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppIStreamPtr = &ppIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ppIStreamPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPersistOptions(uint* pdwPersistOptions) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pdwPersistOptions); + return ret; + } + + /// To be documented. + public readonly int GetPersistOptions(ref uint pdwPersistOptions) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (uint* pdwPersistOptionsPtr = &pdwPersistOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pdwPersistOptionsPtr); + } + return ret; + } + + /// To be documented. + public readonly unsafe int GetPreferredVendorGUID(Guid* pguidPreferredVendor) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidPreferredVendor); + return ret; + } + + /// To be documented. + public readonly int GetPreferredVendorGUID(ref Guid pguidPreferredVendor) + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + fixed (Guid* pguidPreferredVendorPtr = &pguidPreferredVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidPreferredVendorPtr); + } + return ret; + } + + /// To be documented. + public readonly int RefreshStream() + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this); + return ret; + } + + /// To be documented. + public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public readonly int GetStream(ref ComPtr ppIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // ComPtrOverloader + return @this->GetStream((Silk.NET.Core.Win32Extras.IStream**) ppIStream.GetAddressOf()); + } + + /// To be documented. + public readonly ComPtr QueryInterface() where TI0 : unmanaged, IComVtbl + { + var @this = (IWICStreamProvider*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs new file mode 100644 index 0000000000..2bf553a952 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs @@ -0,0 +1,53 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + public unsafe readonly struct PfnProgressNotification : IDisposable + { + private readonly void* _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public PfnProgressNotification + ( + delegate* unmanaged[Cdecl] ptr + ) => _handle = ptr; + + public PfnProgressNotification + ( + ProgressNotification proc + ) => _handle = (void*) SilkMarshal.DelegateToPtr(proc); + + public static PfnProgressNotification From(ProgressNotification proc) => new PfnProgressNotification(proc); + public void Dispose() => SilkMarshal.Free((nint) _handle); + + public static implicit operator nint(PfnProgressNotification pfn) => (nint) pfn.Handle; + public static explicit operator PfnProgressNotification(nint pfn) + => new PfnProgressNotification((delegate* unmanaged[Cdecl]) pfn); + + public static implicit operator PfnProgressNotification(ProgressNotification proc) + => new PfnProgressNotification(proc); + + public static explicit operator ProgressNotification(PfnProgressNotification pfn) + => SilkMarshal.PtrToDelegate(pfn); + + public static implicit operator delegate* unmanaged[Cdecl](PfnProgressNotification pfn) => pfn.Handle; + public static implicit operator PfnProgressNotification(delegate* unmanaged[Cdecl] ptr) => new PfnProgressNotification(ptr); + } + + [UnmanagedFunctionPointer(CallingConvention.Cdecl)] + public unsafe delegate int ProgressNotification(void* arg0, uint arg1, WICProgressOperation arg2, double arg3); +} + diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs new file mode 100644 index 0000000000..c51490f559 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs @@ -0,0 +1,524 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapClipperVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); + } + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, prc); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pISource, in prc.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, in prc); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), prc); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), in prc.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..819c97f417 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs @@ -0,0 +1,1504 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapCodecInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActual); + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pguidPixelFormats, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, ref char wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, ref char wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, ref char wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, ref char wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, ref char wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, ref char wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportAnimation(this ComPtr thisVtbl, int* pfSupportAnimation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimation); + return ret; + } + + /// To be documented. + public static int DoesSupportAnimation(this ComPtr thisVtbl, ref int pfSupportAnimation) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportAnimationPtr = &pfSupportAnimation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimationPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportChromakey(this ComPtr thisVtbl, int* pfSupportChromakey) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakey); + return ret; + } + + /// To be documented. + public static int DoesSupportChromakey(this ComPtr thisVtbl, ref int pfSupportChromakey) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportChromakeyPtr = &pfSupportChromakey) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakeyPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportLossless(this ComPtr thisVtbl, int* pfSupportLossless) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLossless); + return ret; + } + + /// To be documented. + public static int DoesSupportLossless(this ComPtr thisVtbl, ref int pfSupportLossless) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportLosslessPtr = &pfSupportLossless) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLosslessPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportMultiframe(this ComPtr thisVtbl, int* pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframe); + return ret; + } + + /// To be documented. + public static int DoesSupportMultiframe(this ComPtr thisVtbl, ref int pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportMultiframePtr = &pfSupportMultiframe) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatches); + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + } + return ret; + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, pguidPixelFormats, ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pguidPixelFormats.GetPinnableReference(), pcActual); + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pguidPixelFormats, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pguidPixelFormats.GetPinnableReference(), ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, wzColorManagementVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, Span wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, ref wzColorManagementVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, Span wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, ref wzColorManagementVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, wzColorManagementVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, wzMimeTypes, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, Span wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, ref wzMimeTypes.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, Span wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, ref wzMimeTypes.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, wzMimeTypes, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, wzFileExtensions, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, Span wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, ref wzFileExtensions.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, Span wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, ref wzFileExtensions.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, wzFileExtensions, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportAnimation(this ComPtr thisVtbl, Span pfSupportAnimation) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportAnimation(ref pfSupportAnimation.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportChromakey(this ComPtr thisVtbl, Span pfSupportChromakey) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportChromakey(ref pfSupportChromakey.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportLossless(this ComPtr thisVtbl, Span pfSupportLossless) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportLossless(ref pfSupportLossless.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportMultiframe(this ComPtr thisVtbl, Span pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportMultiframe(ref pfSupportMultiframe.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(wzMimeType, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(in wzMimeType.GetPinnableReference(), pfMatches); + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(in wzMimeType.GetPinnableReference(), ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(wzMimeType, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecProgressNotificationVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecProgressNotificationVtblExtensions.gen.cs new file mode 100644 index 0000000000..1a67dff08d --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecProgressNotificationVtblExtensions.gen.cs @@ -0,0 +1,150 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapCodecProgressNotificationVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int RegisterProgressNotification(this ComPtr thisVtbl, PfnProgressNotification pfnProgressNotification, void* pvData, uint dwProgressFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfnProgressNotification, pvData, dwProgressFlags); + return ret; + } + + /// To be documented. + public static int RegisterProgressNotification(this ComPtr thisVtbl, PfnProgressNotification pfnProgressNotification, ref T0 pvData, uint dwProgressFlags) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvDataPtr = &pvData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfnProgressNotification, pvDataPtr, dwProgressFlags); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int RegisterProgressNotification(this ComPtr thisVtbl, PfnProgressNotification pfnProgressNotification, Span pvData, uint dwProgressFlags) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RegisterProgressNotification(pfnProgressNotification, ref pvData.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..50396fda3f --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs @@ -0,0 +1,1785 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapDecoderInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActual); + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pguidPixelFormats, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, ref char wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, ref char wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, ref char wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, ref char wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, ref char wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, ref char wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportAnimation(this ComPtr thisVtbl, int* pfSupportAnimation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimation); + return ret; + } + + /// To be documented. + public static int DoesSupportAnimation(this ComPtr thisVtbl, ref int pfSupportAnimation) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportAnimationPtr = &pfSupportAnimation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimationPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportChromakey(this ComPtr thisVtbl, int* pfSupportChromakey) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakey); + return ret; + } + + /// To be documented. + public static int DoesSupportChromakey(this ComPtr thisVtbl, ref int pfSupportChromakey) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportChromakeyPtr = &pfSupportChromakey) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakeyPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportLossless(this ComPtr thisVtbl, int* pfSupportLossless) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLossless); + return ret; + } + + /// To be documented. + public static int DoesSupportLossless(this ComPtr thisVtbl, ref int pfSupportLossless) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportLosslessPtr = &pfSupportLossless) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLosslessPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportMultiframe(this ComPtr thisVtbl, int* pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframe); + return ret; + } + + /// To be documented. + public static int DoesSupportMultiframe(this ComPtr thisVtbl, ref int pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportMultiframePtr = &pfSupportMultiframe) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatches); + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + } + return ret; + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcPatternsPtr = &pcPatterns) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcPatternsPtr = &pcPatterns) + { + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + fixed (uint* pcPatternsPtr = &pcPatterns) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActual); + } + } + return ret; + } + + /// To be documented. + public static int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + { + fixed (uint* pcPatternsPtr = &pcPatterns) + { + fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStream, pfMatches); + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStream, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStreamPtr, pfMatches); + } + return ret; + } + + /// To be documented. + public static int MatchesPattern(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIStreamPtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, IWICBitmapDecoder** ppIBitmapDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, ppIBitmapDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref IWICBitmapDecoder* ppIBitmapDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIBitmapDecoderPtr = &ppIBitmapDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, ppIBitmapDecoderPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, pguidPixelFormats, ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pguidPixelFormats.GetPinnableReference(), pcActual); + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pguidPixelFormats, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pguidPixelFormats.GetPinnableReference(), ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, wzColorManagementVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, Span wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, ref wzColorManagementVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, Span wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, ref wzColorManagementVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, wzColorManagementVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, wzMimeTypes, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, Span wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, ref wzMimeTypes.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, Span wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, ref wzMimeTypes.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, wzMimeTypes, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, wzFileExtensions, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, Span wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, ref wzFileExtensions.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, Span wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, ref wzFileExtensions.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, wzFileExtensions, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportAnimation(this ComPtr thisVtbl, Span pfSupportAnimation) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportAnimation(ref pfSupportAnimation.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportChromakey(this ComPtr thisVtbl, Span pfSupportChromakey) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportChromakey(ref pfSupportChromakey.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportLossless(this ComPtr thisVtbl, Span pfSupportLossless) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportLossless(ref pfSupportLossless.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportMultiframe(this ComPtr thisVtbl, Span pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportMultiframe(ref pfSupportMultiframe.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(wzMimeType, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(in wzMimeType.GetPinnableReference(), pfMatches); + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(in wzMimeType.GetPinnableReference(), ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(wzMimeType, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), pcbPatternsActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, pcbPatternsActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), pcbPatternsActual); + } + + /// To be documented. + public static int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, ComPtr pIStream, int* pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MatchesPattern((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(pIStream, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int MatchesPattern(this ComPtr thisVtbl, ComPtr pIStream, ref int pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MatchesPattern((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Span pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(ref pIStream.GetPinnableReference(), pfMatches); + } + + /// To be documented. + public static int MatchesPattern(this ComPtr thisVtbl, Span pIStream, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(ref pIStream.GetPinnableReference(), ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref ComPtr ppIBitmapDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((IWICBitmapDecoder**) ppIBitmapDecoder.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs new file mode 100644 index 0000000000..85e1b90af0 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs @@ -0,0 +1,566 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapDecoderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int QueryCapability(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, uint* pdwCapability) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, pdwCapability); + return ret; + } + + /// To be documented. + public static unsafe int QueryCapability(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, ref uint pdwCapability) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwCapabilityPtr = &pdwCapability) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, pdwCapabilityPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryCapability(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, uint* pdwCapability) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, pdwCapability); + } + return ret; + } + + /// To be documented. + public static int QueryCapability(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref uint pdwCapability) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (uint* pdwCapabilityPtr = &pdwCapability) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, pdwCapabilityPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, WICDecodeOptions cacheOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, cacheOptions); + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, WICDecodeOptions cacheOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, cacheOptions); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDecoderInfo(this ComPtr thisVtbl, IWICBitmapDecoderInfo** ppIDecoderInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIDecoderInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetDecoderInfo(this ComPtr thisVtbl, ref IWICBitmapDecoderInfo* ppIDecoderInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoderInfo** ppIDecoderInfoPtr = &ppIDecoderInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIDecoderInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryReader(this ComPtr thisVtbl, IWICMetadataQueryReader** ppIMetadataQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReader); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader* ppIMetadataQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader** ppIMetadataQueryReaderPtr = &ppIMetadataQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPreview(this ComPtr thisVtbl, IWICBitmapSource** ppIBitmapSource) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIBitmapSource); + return ret; + } + + /// To be documented. + public static unsafe int GetPreview(this ComPtr thisVtbl, ref IWICBitmapSource* ppIBitmapSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppIBitmapSourcePtr = &ppIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIBitmapSourcePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContexts, pcActualCount); + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, ref uint pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContexts, pcActualCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, uint* pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContextsPtr, pcActualCount); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, ref uint pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cCount, ppIColorContextsPtr, pcActualCountPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetThumbnail(this ComPtr thisVtbl, IWICBitmapSource** ppIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIThumbnail); + return ret; + } + + /// To be documented. + public static unsafe int GetThumbnail(this ComPtr thisVtbl, ref IWICBitmapSource* ppIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppIThumbnailPtr = &ppIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFrameCount(this ComPtr thisVtbl, uint* pCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pCount); + return ret; + } + + /// To be documented. + public static int GetFrameCount(this ComPtr thisVtbl, ref uint pCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pCountPtr = &pCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFrame(this ComPtr thisVtbl, uint index, IWICBitmapFrameDecode** ppIBitmapFrame) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, index, ppIBitmapFrame); + return ret; + } + + /// To be documented. + public static unsafe int GetFrame(this ComPtr thisVtbl, uint index, ref IWICBitmapFrameDecode* ppIBitmapFrame) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode** ppIBitmapFramePtr = &ppIBitmapFrame) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, index, ppIBitmapFramePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int QueryCapability(this ComPtr thisVtbl, ComPtr pIStream, uint* pdwCapability) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->QueryCapability((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pdwCapability); + } + + /// To be documented. + public static unsafe int QueryCapability(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pdwCapability) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryCapability(pIStream, ref pdwCapability.GetPinnableReference()); + } + + /// To be documented. + public static int QueryCapability(this ComPtr thisVtbl, ComPtr pIStream, ref uint pdwCapability) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->QueryCapability((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pdwCapability); + } + + /// To be documented. + public static unsafe int QueryCapability(this ComPtr thisVtbl, Span pIStream, uint* pdwCapability) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryCapability(ref pIStream.GetPinnableReference(), pdwCapability); + } + + /// To be documented. + public static int QueryCapability(this ComPtr thisVtbl, Span pIStream, Span pdwCapability) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryCapability(ref pIStream.GetPinnableReference(), ref pdwCapability.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIStream, WICDecodeOptions cacheOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, cacheOptions); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pIStream, WICDecodeOptions cacheOptions) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIStream.GetPinnableReference(), cacheOptions); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetDecoderInfo(this ComPtr thisVtbl, ref ComPtr ppIDecoderInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetDecoderInfo((IWICBitmapDecoderInfo**) ppIDecoderInfo.GetAddressOf()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataQueryReader(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataQueryReader((IWICMetadataQueryReader**) ppIMetadataQueryReader.GetAddressOf()); + } + + /// To be documented. + public static int GetPreview(this ComPtr thisVtbl, ref ComPtr ppIBitmapSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetPreview((IWICBitmapSource**) ppIBitmapSource.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContexts, uint* pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), pcActualCount); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, Span pcActualCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorContexts(cCount, ppIColorContexts, ref pcActualCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContexts, ref uint pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), ref pcActualCount); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, Span pcActualCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorContexts(cCount, ref ppIColorContexts, ref pcActualCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetThumbnail(this ComPtr thisVtbl, ref ComPtr ppIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); + } + + /// To be documented. + public static int GetFrameCount(this ComPtr thisVtbl, Span pCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFrameCount(ref pCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetFrame(this ComPtr thisVtbl, uint index, ref ComPtr ppIBitmapFrame) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetFrame(index, (IWICBitmapFrameDecode**) ppIBitmapFrame.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..f3ccfd7eb3 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs @@ -0,0 +1,1533 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapEncoderInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActual); + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormats, pcActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pguidPixelFormats, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPixelFormatsPtr = &pguidPixelFormats) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cFormats, pguidPixelFormatsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, ref char wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, ref char wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzColorManagementVersionPtr = &wzColorManagementVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzColorManagementVersionPtr = (byte*) SilkMarshal.StringToPtr(wzColorManagementVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchColorManagementVersion, wzColorManagementVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzColorManagementVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypes, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, ref char wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, ref char wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypesPtr = &wzMimeTypes) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActual); + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypesPtr = (byte*) SilkMarshal.StringToPtr(wzMimeTypes, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, cchMimeTypes, wzMimeTypesPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzMimeTypesPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensions, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, ref char wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, ref char wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileExtensionsPtr = &wzFileExtensions) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActual); + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileExtensionsPtr = (byte*) SilkMarshal.StringToPtr(wzFileExtensions, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, cchFileExtensions, wzFileExtensionsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFileExtensionsPtr); + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportAnimation(this ComPtr thisVtbl, int* pfSupportAnimation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimation); + return ret; + } + + /// To be documented. + public static int DoesSupportAnimation(this ComPtr thisVtbl, ref int pfSupportAnimation) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportAnimationPtr = &pfSupportAnimation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pfSupportAnimationPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportChromakey(this ComPtr thisVtbl, int* pfSupportChromakey) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakey); + return ret; + } + + /// To be documented. + public static int DoesSupportChromakey(this ComPtr thisVtbl, ref int pfSupportChromakey) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportChromakeyPtr = &pfSupportChromakey) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pfSupportChromakeyPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportLossless(this ComPtr thisVtbl, int* pfSupportLossless) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLossless); + return ret; + } + + /// To be documented. + public static int DoesSupportLossless(this ComPtr thisVtbl, ref int pfSupportLossless) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportLosslessPtr = &pfSupportLossless) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, pfSupportLosslessPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportMultiframe(this ComPtr thisVtbl, int* pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframe); + return ret; + } + + /// To be documented. + public static int DoesSupportMultiframe(this ComPtr thisVtbl, ref int pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportMultiframePtr = &pfSupportMultiframe) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pfSupportMultiframePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatches); + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeType, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + } + return ret; + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzMimeTypePtr = &wzMimeType) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatches); + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzMimeTypePtr = (byte*) SilkMarshal.StringToPtr(wzMimeType, NativeStringEncoding.LPWStr); + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, wzMimeTypePtr, pfMatchesPtr); + } + SilkMarshal.Free((nint)wzMimeTypePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, IWICBitmapEncoder** ppIBitmapEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, ppIBitmapEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref IWICBitmapEncoder* ppIBitmapEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoder** ppIBitmapEncoderPtr = &ppIBitmapEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, ppIBitmapEncoderPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pguidPixelFormats, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, pguidPixelFormats, ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pguidPixelFormats, uint* pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pguidPixelFormats.GetPinnableReference(), pcActual); + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pguidPixelFormats, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pguidPixelFormats.GetPinnableReference(), ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, char* wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, wzColorManagementVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, Span wzColorManagementVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, ref wzColorManagementVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, Span wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, ref wzColorManagementVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorManagementVersion(this ComPtr thisVtbl, uint cchColorManagementVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzColorManagementVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorManagementVersion(cchColorManagementVersion, wzColorManagementVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, char* wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, wzMimeTypes, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, Span wzMimeTypes, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, ref wzMimeTypes.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, Span wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, ref wzMimeTypes.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetMimeTypes(this ComPtr thisVtbl, uint cchMimeTypes, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzMimeTypes, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMimeTypes(cchMimeTypes, wzMimeTypes, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, char* wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, wzFileExtensions, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, Span wzFileExtensions, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, ref wzFileExtensions.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, Span wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, ref wzFileExtensions.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFileExtensions(this ComPtr thisVtbl, uint cchFileExtensions, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFileExtensions, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFileExtensions(cchFileExtensions, wzFileExtensions, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportAnimation(this ComPtr thisVtbl, Span pfSupportAnimation) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportAnimation(ref pfSupportAnimation.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportChromakey(this ComPtr thisVtbl, Span pfSupportChromakey) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportChromakey(ref pfSupportChromakey.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportLossless(this ComPtr thisVtbl, Span pfSupportLossless) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportLossless(ref pfSupportLossless.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportMultiframe(this ComPtr thisVtbl, Span pfSupportMultiframe) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportMultiframe(ref pfSupportMultiframe.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(wzMimeType, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzMimeType, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(in wzMimeType.GetPinnableReference(), pfMatches); + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(in wzMimeType.GetPinnableReference(), ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int MatchesMimeType(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzMimeType, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesMimeType(wzMimeType, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref ComPtr ppIBitmapEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((IWICBitmapEncoder**) ppIBitmapEncoder.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs new file mode 100644 index 0000000000..3fff445bc9 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs @@ -0,0 +1,466 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapEncoderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, WICBitmapEncoderCacheOption cacheOption) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, cacheOption); + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, WICBitmapEncoderCacheOption cacheOption) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, cacheOption); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetEncoderInfo(this ComPtr thisVtbl, IWICBitmapEncoderInfo** ppIEncoderInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIEncoderInfo); + return ret; + } + + /// To be documented. + public static unsafe int GetEncoderInfo(this ComPtr thisVtbl, ref IWICBitmapEncoderInfo* ppIEncoderInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoderInfo** ppIEncoderInfoPtr = &ppIEncoderInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIEncoderInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cCount, ppIColorContext); + return ret; + } + + /// To be documented. + public static unsafe int SetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cCount, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetThumbnail(this ComPtr thisVtbl, IWICBitmapSource* pIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIThumbnail); + return ret; + } + + /// To be documented. + public static int SetThumbnail(this ComPtr thisVtbl, ref IWICBitmapSource pIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIThumbnailPtr = &pIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetPreview(this ComPtr thisVtbl, IWICBitmapSource* pIPreview) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPreview); + return ret; + } + + /// To be documented. + public static int SetPreview(this ComPtr thisVtbl, ref IWICBitmapSource pIPreview) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIPreviewPtr = &pIPreview) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPreviewPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptions); + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncode, ppIEncoderOptionsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Silk.NET.Core.Native.IUnknown** ppIEncoderOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptions); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (Silk.NET.Core.Native.IUnknown** ppIEncoderOptionsPtr = &ppIEncoderOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFrameEncodePtr, ppIEncoderOptionsPtr); + } + } + return ret; + } + + /// To be documented. + public static int Commit(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryWriter(this ComPtr thisVtbl, IWICMetadataQueryWriter** ppIMetadataQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIMetadataQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryWriter(this ComPtr thisVtbl, ref IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIMetadataQueryWriterPtr = &ppIMetadataQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIMetadataQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIStream, WICBitmapEncoderCacheOption cacheOption) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, cacheOption); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pIStream, WICBitmapEncoderCacheOption cacheOption) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIStream.GetPinnableReference(), cacheOption); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetEncoderInfo(this ComPtr thisVtbl, ref ComPtr ppIEncoderInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetEncoderInfo((IWICBitmapEncoderInfo**) ppIEncoderInfo.GetAddressOf()); + } + + /// To be documented. + public static int SetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetColorContexts(cCount, (IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static int SetThumbnail(this ComPtr thisVtbl, ComPtr pIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetThumbnail((IWICBitmapSource*) pIThumbnail.Handle); + } + + /// To be documented. + public static int SetThumbnail(this ComPtr thisVtbl, Span pIThumbnail) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetThumbnail(ref pIThumbnail.GetPinnableReference()); + } + + /// To be documented. + public static int SetPreview(this ComPtr thisVtbl, ComPtr pIPreview) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetPreview((IWICBitmapSource*) pIPreview.Handle); + } + + /// To be documented. + public static int SetPreview(this ComPtr thisVtbl, Span pIPreview) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetPreview(ref pIPreview.GetPinnableReference()); + } + + /// To be documented. + public static int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref Silk.NET.Core.Native.IUnknown* ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref ppIEncoderOptions); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref ComPtr ppIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, (Silk.NET.Core.Native.IUnknown**) ppIEncoderOptions.GetAddressOf()); + } + + /// To be documented. + public static int GetMetadataQueryWriter(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataQueryWriter((IWICMetadataQueryWriter**) ppIMetadataQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs new file mode 100644 index 0000000000..62b7ad9631 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs @@ -0,0 +1,473 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapFlipRotatorVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, WICBitmapTransformOptions options) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, options); + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, WICBitmapTransformOptions options) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, options); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, WICBitmapTransformOptions options) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, options); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pISource, WICBitmapTransformOptions options) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), options); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs new file mode 100644 index 0000000000..b0fd3fea4c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs @@ -0,0 +1,574 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapFrameDecodeVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryReader(this ComPtr thisVtbl, IWICMetadataQueryReader** ppIMetadataQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReader); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader* ppIMetadataQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader** ppIMetadataQueryReaderPtr = &ppIMetadataQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCount); + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, ref uint pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, uint* pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCount); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, ref uint pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCountPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetThumbnail(this ComPtr thisVtbl, IWICBitmapSource** ppIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnail); + return ret; + } + + /// To be documented. + public static unsafe int GetThumbnail(this ComPtr thisVtbl, ref IWICBitmapSource* ppIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppIThumbnailPtr = &ppIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int GetMetadataQueryReader(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataQueryReader((IWICMetadataQueryReader**) ppIMetadataQueryReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContexts, uint* pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), pcActualCount); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, Span pcActualCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorContexts(cCount, ppIColorContexts, ref pcActualCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContexts, ref uint pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), ref pcActualCount); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, Span pcActualCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorContexts(cCount, ref ppIColorContexts, ref pcActualCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetThumbnail(this ComPtr thisVtbl, ref ComPtr ppIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs new file mode 100644 index 0000000000..990bb53076 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs @@ -0,0 +1,474 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapFrameEncodeVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pIEncoderOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptions); + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pIEncoderOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown* pIEncoderOptionsPtr = &pIEncoderOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIEncoderOptionsPtr); + } + return ret; + } + + /// To be documented. + public static int SetSize(this ComPtr thisVtbl, uint uiWidth, uint uiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, uiWidth, uiHeight); + return ret; + } + + /// To be documented. + public static int SetResolution(this ComPtr thisVtbl, double dpiX, double dpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, dpiX, dpiY); + return ret; + } + + /// To be documented. + public static unsafe int SetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int SetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cCount, ppIColorContext); + return ret; + } + + /// To be documented. + public static unsafe int SetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cCount, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetThumbnail(this ComPtr thisVtbl, IWICBitmapSource* pIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIThumbnail); + return ret; + } + + /// To be documented. + public static int SetThumbnail(this ComPtr thisVtbl, ref IWICBitmapSource pIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIThumbnailPtr = &pIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WritePixels(this ComPtr thisVtbl, uint lineCount, uint cbStride, uint cbBufferSize, byte* pbPixels) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, lineCount, cbStride, cbBufferSize, pbPixels); + return ret; + } + + /// To be documented. + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, uint cbStride, uint cbBufferSize, ref byte pbPixels) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbPixelsPtr = &pbPixels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, lineCount, cbStride, cbBufferSize, pbPixelsPtr); + } + return ret; + } + + /// To be documented. + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbPixels) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbPixelsPtr = (byte*) SilkMarshal.StringToPtr(pbPixels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, lineCount, cbStride, cbBufferSize, pbPixelsPtr); + SilkMarshal.Free((nint)pbPixelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICRect* prc) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref WICRect prc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICRect* prc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); + } + return ret; + } + + /// To be documented. + public static int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref WICRect prc) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); + } + } + return ret; + } + + /// To be documented. + public static int Commit(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryWriter(this ComPtr thisVtbl, IWICMetadataQueryWriter** ppIMetadataQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIMetadataQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryWriter(this ComPtr thisVtbl, ref IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIMetadataQueryWriterPtr = &ppIMetadataQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIMetadataQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIEncoderOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((Silk.NET.Core.Native.IUnknown*) pIEncoderOptions.Handle); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pIEncoderOptions) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIEncoderOptions.GetPinnableReference()); + } + + /// To be documented. + public static int SetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static int SetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetColorContexts(cCount, (IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static int SetThumbnail(this ComPtr thisVtbl, ComPtr pIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetThumbnail((IWICBitmapSource*) pIThumbnail.Handle); + } + + /// To be documented. + public static int SetThumbnail(this ComPtr thisVtbl, Span pIThumbnail) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetThumbnail(ref pIThumbnail.GetPinnableReference()); + } + + /// To be documented. + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, uint cbStride, uint cbBufferSize, Span pbPixels) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WritePixels(lineCount, cbStride, cbBufferSize, ref pbPixels.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource*) pIBitmapSource.Handle, prc); + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span prc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteSource(pIBitmapSource, ref prc.GetPinnableReference()); + } + + /// To be documented. + public static int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource*) pIBitmapSource.Handle, ref prc); + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, WICRect* prc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteSource(ref pIBitmapSource.GetPinnableReference(), prc); + } + + /// To be documented. + public static int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Span prc) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteSource(ref pIBitmapSource.GetPinnableReference(), ref prc.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataQueryWriter(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataQueryWriter((IWICMetadataQueryWriter**) ppIMetadataQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapLockVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapLockVtblExtensions.gen.cs new file mode 100644 index 0000000000..9364e9b487 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapLockVtblExtensions.gen.cs @@ -0,0 +1,339 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapLockVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetStride(this ComPtr thisVtbl, uint* pcbStride) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcbStride); + return ret; + } + + /// To be documented. + public static int GetStride(this ComPtr thisVtbl, ref uint pcbStride) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbStridePtr = &pcbStride) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcbStridePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, uint* pcbBufferSize, byte** ppbData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSize, ppbData); + return ret; + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, uint* pcbBufferSize, ref byte* ppbData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte** ppbDataPtr = &ppbData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSize, ppbDataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, ref uint pcbBufferSize, byte** ppbData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbBufferSizePtr = &pcbBufferSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSizePtr, ppbData); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, ref uint pcbBufferSize, ref byte* ppbData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbBufferSizePtr = &pcbBufferSize) + { + fixed (byte** ppbDataPtr = &ppbData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcbBufferSizePtr, ppbDataPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetStride(this ComPtr thisVtbl, Span pcbStride) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetStride(ref pcbStride.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, uint* pcbBufferSize, string[] ppbDataSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppbData = (byte**) SilkMarshal.StringArrayToPtr(ppbDataSa); + var ret = @this->GetDataPointer(pcbBufferSize, ppbData); + SilkMarshal.CopyPtrToStringArray((nint) ppbData, ppbDataSa); + SilkMarshal.Free((nint) ppbData); + return ret; + } + + /// To be documented. + public static int GetDataPointer(this ComPtr thisVtbl, ref uint pcbBufferSize, string[] ppbDataSa) + { + var @this = thisVtbl.Handle; + // StringArrayOverloader + var ppbData = (byte**) SilkMarshal.StringArrayToPtr(ppbDataSa); + var ret = @this->GetDataPointer(ref pcbBufferSize, ppbData); + SilkMarshal.CopyPtrToStringArray((nint) ppbData, ppbDataSa); + SilkMarshal.Free((nint) ppbData); + return ret; + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, Span pcbBufferSize, byte** ppbData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDataPointer(ref pcbBufferSize.GetPinnableReference(), ppbData); + } + + /// To be documented. + public static unsafe int GetDataPointer(this ComPtr thisVtbl, Span pcbBufferSize, ref byte* ppbData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDataPointer(ref pcbBufferSize.GetPinnableReference(), ref ppbData); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs new file mode 100644 index 0000000000..3b37a66309 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapPattern")] + public unsafe partial struct WICBitmapPattern + { + public WICBitmapPattern + ( + ulong? position = null, + uint? length = null, + byte* pattern = null, + byte* mask = null, + Silk.NET.Core.Bool32? endOfStream = null + ) : this() + { + if (position is not null) + { + Position = position.Value; + } + + if (length is not null) + { + Length = length.Value; + } + + if (pattern is not null) + { + Pattern = pattern; + } + + if (mask is not null) + { + Mask = mask; + } + + if (endOfStream is not null) + { + EndOfStream = endOfStream.Value; + } + } + + + [NativeName("Type", "ULARGE_INTEGER")] + [NativeName("Type.Name", "ULARGE_INTEGER")] + [NativeName("Name", "Position")] + public ulong Position; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "Length")] + public uint Length; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "Pattern")] + public byte* Pattern; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "Mask")] + public byte* Mask; + + [NativeName("Type", "BOOL")] + [NativeName("Type.Name", "BOOL")] + [NativeName("Name", "EndOfStream")] + public Silk.NET.Core.Bool32 EndOfStream; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs new file mode 100644 index 0000000000..e7f420440c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapPlane")] + public unsafe partial struct WICBitmapPlane + { + public WICBitmapPlane + ( + Guid? format = null, + byte* pbBuffer = null, + uint? cbStride = null, + uint? cbBufferSize = null + ) : this() + { + if (format is not null) + { + Format = format.Value; + } + + if (pbBuffer is not null) + { + PbBuffer = pbBuffer; + } + + if (cbStride is not null) + { + CbStride = cbStride.Value; + } + + if (cbBufferSize is not null) + { + CbBufferSize = cbBufferSize.Value; + } + } + + + [NativeName("Type", "WICPixelFormatGUID")] + [NativeName("Type.Name", "WICPixelFormatGUID")] + [NativeName("Name", "Format")] + public Guid Format; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "pbBuffer")] + public byte* PbBuffer; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "cbStride")] + public uint CbStride; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "cbBufferSize")] + public uint CbBufferSize; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs new file mode 100644 index 0000000000..9c3e5ce433 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs @@ -0,0 +1,61 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICBitmapPlaneDescription")] + public unsafe partial struct WICBitmapPlaneDescription + { + public WICBitmapPlaneDescription + ( + Guid? format = null, + uint? width = null, + uint? height = null + ) : this() + { + if (format is not null) + { + Format = format.Value; + } + + if (width is not null) + { + Width = width.Value; + } + + if (height is not null) + { + Height = height.Value; + } + } + + + [NativeName("Type", "WICPixelFormatGUID")] + [NativeName("Type.Name", "WICPixelFormatGUID")] + [NativeName("Name", "Format")] + public Guid Format; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Width")] + public uint Width; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Height")] + public uint Height; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs new file mode 100644 index 0000000000..66442399cc --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs @@ -0,0 +1,473 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapScalerVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, uiWidth, uiHeight, mode); + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, uiWidth, uiHeight, mode); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, uiWidth, uiHeight, mode); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), uiWidth, uiHeight, mode); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs new file mode 100644 index 0000000000..0a7ed7bdc0 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs @@ -0,0 +1,495 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapSourceTransformVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetClosestSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetClosestSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetClosestSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetClosestSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetClosestPixelFormat(this ComPtr thisVtbl, Guid* pguidDstFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidDstFormat); + return ret; + } + + /// To be documented. + public static int GetClosestPixelFormat(this ComPtr thisVtbl, ref Guid pguidDstFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidDstFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, WICBitmapTransformOptions dstTransform, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupported); + return ret; + } + + /// To be documented. + public static int DoesSupportTransform(this ComPtr thisVtbl, WICBitmapTransformOptions dstTransform, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupportedPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, uiWidth, uiHeight, ref pguidDstFormat.GetPinnableReference(), dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, uiWidth, uiHeight, ref pguidDstFormat.GetPinnableReference(), dstTransform, nStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, uiWidth, uiHeight, ref pguidDstFormat.GetPinnableReference(), dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), uiWidth, uiHeight, ref pguidDstFormat.GetPinnableReference(), dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), uiWidth, uiHeight, ref pguidDstFormat.GetPinnableReference(), dstTransform, nStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), uiWidth, uiHeight, ref pguidDstFormat.GetPinnableReference(), dstTransform, nStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int GetClosestSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClosestSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetClosestSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClosestSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetClosestSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClosestSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetClosestPixelFormat(this ComPtr thisVtbl, Span pguidDstFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClosestPixelFormat(ref pguidDstFormat.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportTransform(this ComPtr thisVtbl, WICBitmapTransformOptions dstTransform, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(dstTransform, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs new file mode 100644 index 0000000000..ad135b899c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs @@ -0,0 +1,436 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapSourceVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs new file mode 100644 index 0000000000..9998f4d24c --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs @@ -0,0 +1,562 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICBitmapVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, IWICBitmapLock** ppILock) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); + return ret; + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref IWICBitmapLock* ppILock) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapLock** ppILockPtr = &ppILock) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, IWICBitmapLock** ppILock) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcLockPtr = &prcLock) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); + } + return ret; + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref IWICBitmapLock* ppILock) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcLockPtr = &prcLock) + { + fixed (IWICBitmapLock** ppILockPtr = &ppILock) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static int SetResolution(this ComPtr thisVtbl, double dpiX, double dpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, dpiX, dpiY); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Lock(prcLock, flags, (IWICBitmapLock**) ppILock.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, IWICBitmapLock** ppILock) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Lock(in prcLock.GetPinnableReference(), flags, ppILock); + } + + /// To be documented. + public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Lock(in prcLock, flags, (IWICBitmapLock**) ppILock.GetAddressOf()); + } + + /// To be documented. + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, ref IWICBitmapLock* ppILock) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Lock(in prcLock.GetPinnableReference(), flags, ref ppILock); + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int SetPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs new file mode 100644 index 0000000000..4bff878784 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs @@ -0,0 +1,373 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICColorContextVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename); + return ret; + } + + /// To be documented. + public static int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr); + } + return ret; + } + + /// To be documented. + public static int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromMemory(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pbBuffer, cbBufferSize); + return ret; + } + + /// To be documented. + public static int InitializeFromMemory(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pbBufferPtr, cbBufferSize); + } + return ret; + } + + /// To be documented. + public static int InitializeFromMemory(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pbBufferPtr, cbBufferSize); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static int InitializeFromExifColorSpace(this ComPtr thisVtbl, uint value) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, value); + return ret; + } + + /// To be documented. + public static unsafe int GetType(this ComPtr thisVtbl, WICColorContextType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetType(this ComPtr thisVtbl, ref WICColorContextType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICColorContextType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, byte* pbBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBuffer, pcbActual); + return ret; + } + + /// To be documented. + public static unsafe int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, byte* pbBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBuffer, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, ref byte pbBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public static int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, ref byte pbBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActual); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, cbBuffer, pbBufferPtr, pcbActualPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetExifColorSpace(this ComPtr thisVtbl, uint* pValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pValue); + return ret; + } + + /// To be documented. + public static int GetExifColorSpace(this ComPtr thisVtbl, ref uint pValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pValuePtr = &pValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pValuePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromFilename(in wzFilename.GetPinnableReference()); + } + + /// To be documented. + public static int InitializeFromMemory(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromMemory(in pbBuffer.GetPinnableReference(), cbBufferSize); + } + + /// To be documented. + public static int GetType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, byte* pbBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetProfileBytes(cbBuffer, pbBuffer, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, Span pbBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetProfileBytes(cbBuffer, ref pbBuffer.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, Span pbBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetProfileBytes(cbBuffer, ref pbBuffer.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetProfileBytes(this ComPtr thisVtbl, uint cbBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetProfileBytes(cbBuffer, pbBuffer, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetExifColorSpace(this ComPtr thisVtbl, Span pValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetExifColorSpace(ref pValue.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs new file mode 100644 index 0000000000..e939a28dba --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs @@ -0,0 +1,908 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICColorTransformVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDest, pixelFmtDest); + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDest, pixelFmtDestPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDestPtr, pixelFmtDest); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSource, pIContextDestPtr, pixelFmtDestPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDest, pixelFmtDest); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDest, pixelFmtDestPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDestPtr, pixelFmtDest); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSource, pIContextSourcePtr, pIContextDestPtr, pixelFmtDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDest, pixelFmtDest); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDest, pixelFmtDestPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDestPtr, pixelFmtDest); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, IWICColorContext* pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSource, pIContextDestPtr, pixelFmtDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDest, pixelFmtDest); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, IWICColorContext* pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDest, pixelFmtDestPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDestPtr, pixelFmtDest); + } + } + } + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICColorContext* pIContextSourcePtr = &pIContextSource) + { + fixed (IWICColorContext* pIContextDestPtr = &pIContextDest) + { + fixed (Guid* pixelFmtDestPtr = &pixelFmtDest) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIBitmapSourcePtr, pIContextSourcePtr, pIContextDestPtr, pixelFmtDestPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, pIContextSource, pIContextDest, ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl where TI2 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, Span pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, pIContextSource, ref pIContextDest.GetPinnableReference(), pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, IWICColorContext* pIContextSource, Span pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, pIContextSource, ref pIContextDest.GetPinnableReference(), ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, ref pIContextSource.GetPinnableReference(), pIContextDest, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span pIContextSource, IWICColorContext* pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, ref pIContextSource.GetPinnableReference(), pIContextDest, ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span pIContextSource, Span pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, ref pIContextSource.GetPinnableReference(), ref pIContextDest.GetPinnableReference(), pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, ref pIContextDest, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span pIContextSource, Span pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pIBitmapSource, ref pIContextSource.GetPinnableReference(), ref pIContextDest.GetPinnableReference(), ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref IWICColorContext pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pIBitmapSource.Handle, ref pIContextSource, ref pIContextDest, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), pIContextSource, pIContextDest, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, IWICColorContext* pIContextSource, IWICColorContext* pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), pIContextSource, pIContextDest, ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, IWICColorContext* pIContextSource, Span pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), pIContextSource, ref pIContextDest.GetPinnableReference(), pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, IWICColorContext* pIContextSource, Span pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), pIContextSource, ref pIContextDest.GetPinnableReference(), ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ComPtr pIContextSource, ref IWICColorContext pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, (IWICColorContext*) pIContextSource.Handle, ref pIContextDest, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, Span pIContextSource, IWICColorContext* pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), ref pIContextSource.GetPinnableReference(), pIContextDest, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, Guid* pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, Span pIContextSource, IWICColorContext* pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), ref pIContextSource.GetPinnableReference(), pIContextDest, ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref IWICColorContext pIContextSource, ComPtr pIContextDest, ref Guid pixelFmtDest) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pIBitmapSource, ref pIContextSource, (IWICColorContext*) pIContextDest.Handle, ref pixelFmtDest); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, Span pIContextSource, Span pIContextDest, Guid* pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), ref pIContextSource.GetPinnableReference(), ref pIContextDest.GetPinnableReference(), pixelFmtDest); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pIBitmapSource, Span pIContextSource, Span pIContextDest, Span pixelFmtDest) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pIBitmapSource.GetPinnableReference(), ref pIContextSource.GetPinnableReference(), ref pIContextDest.GetPinnableReference(), ref pixelFmtDest.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs new file mode 100644 index 0000000000..e105eb7867 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs @@ -0,0 +1,4412 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICComponentFactoryVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Guid* clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfo); + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Guid* clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfo); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreatePalette(this ComPtr thisVtbl, IWICPalette** ppIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalette); + return ret; + } + + /// To be documented. + public static unsafe int CreatePalette(this ComPtr thisVtbl, ref IWICPalette* ppIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette** ppIPalettePtr = &ppIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFormatConverter(this ComPtr thisVtbl, IWICFormatConverter** ppIFormatConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverter); + return ret; + } + + /// To be documented. + public static unsafe int CreateFormatConverter(this ComPtr thisVtbl, ref IWICFormatConverter* ppIFormatConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFormatConverter** ppIFormatConverterPtr = &ppIFormatConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapScaler(this ComPtr thisVtbl, IWICBitmapScaler** ppIBitmapScaler) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScaler); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapScaler(this ComPtr thisVtbl, ref IWICBitmapScaler* ppIBitmapScaler) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapScaler** ppIBitmapScalerPtr = &ppIBitmapScaler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScalerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapClipper(this ComPtr thisVtbl, IWICBitmapClipper** ppIBitmapClipper) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipper); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapClipper(this ComPtr thisVtbl, ref IWICBitmapClipper* ppIBitmapClipper) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapClipper** ppIBitmapClipperPtr = &ppIBitmapClipper) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipperPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFlipRotator(this ComPtr thisVtbl, IWICBitmapFlipRotator** ppIBitmapFlipRotator) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotator); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFlipRotator(this ComPtr thisVtbl, ref IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFlipRotator** ppIBitmapFlipRotatorPtr = &ppIBitmapFlipRotator) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotatorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, IWICStream** ppIWICStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStream); + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, ref IWICStream* ppIWICStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICStream** ppIWICStreamPtr = &ppIWICStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateColorContext(this ComPtr thisVtbl, IWICColorContext** ppIWICColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContext); + return ret; + } + + /// To be documented. + public static unsafe int CreateColorContext(this ComPtr thisVtbl, ref IWICColorContext* ppIWICColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIWICColorContextPtr = &ppIWICColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateColorTransformer(this ComPtr thisVtbl, IWICColorTransform** ppIWICColorTransform) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransform); + return ret; + } + + /// To be documented. + public static unsafe int CreateColorTransformer(this ComPtr thisVtbl, ref IWICColorTransform* ppIWICColorTransform) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorTransform** ppIWICColorTransformPtr = &ppIWICColorTransform) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransformPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentEnumerator(this ComPtr thisVtbl, uint componentTypes, uint options, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknown); + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentEnumerator(this ComPtr thisVtbl, uint componentTypes, uint options, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknownPtr = &ppIEnumUnknown) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, IWICBitmapDecoder* pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, IWICBitmapFrameDecode* pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStream, ppIReader); + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStream, ppIReader); + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormat, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStream, ppIReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStream, ppIReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReader); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendor, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReader); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStream, ppIReaderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReader); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, guidContainerFormatPtr, pguidVendorPtr, dwOptions, pIStreamPtr, ppIReaderPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendor, dwMetadataOptions, ppIWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendor, dwMetadataOptions, ppIWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendorPtr, dwMetadataOptions, ppIWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormat, pguidVendorPtr, dwMetadataOptions, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendor, dwMetadataOptions, ppIWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendor, dwMetadataOptions, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwMetadataOptions, ppIWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, guidMetadataFormatPtr, pguidVendorPtr, dwMetadataOptions, ppIWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendor, ppIWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendor, ppIWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendorPtr, ppIWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReader, pguidVendorPtr, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendor, ppIWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendor, ppIWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendorPtr, ppIWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader* pIReaderPtr = &pIReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, pIReaderPtr, pguidVendorPtr, ppIWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, IWICMetadataBlockReader* pIBlockReader, IWICMetadataQueryReader** ppIQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReader, ppIQueryReader); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, IWICMetadataBlockReader* pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader** ppIQueryReaderPtr = &ppIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReader, ppIQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, ref IWICMetadataBlockReader pIBlockReader, IWICMetadataQueryReader** ppIQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataBlockReader* pIBlockReaderPtr = &pIBlockReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReaderPtr, ppIQueryReader); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, ref IWICMetadataBlockReader pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataBlockReader* pIBlockReaderPtr = &pIBlockReader) + { + fixed (IWICMetadataQueryReader** ppIQueryReaderPtr = &ppIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pIBlockReaderPtr, ppIQueryReaderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, IWICMetadataBlockWriter* pIBlockWriter, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriter, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, IWICMetadataBlockWriter* pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriter, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, ref IWICMetadataBlockWriter pIBlockWriter, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataBlockWriter* pIBlockWriterPtr = &pIBlockWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriterPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, ref IWICMetadataBlockWriter pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataBlockWriter* pIBlockWriterPtr = &pIBlockWriter) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, pIBlockWriterPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, void* ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBag); + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, void* ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptions, cCount, ppIPropertyBagPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref T0 ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* ppropOptionsPtr = &ppropOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBag); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref T0 ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* ppropOptionsPtr = &ppropOptions) + { + fixed (Silk.NET.Core.Native.IUnknown** ppIPropertyBagPtr = &ppIPropertyBag) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, ppropOptionsPtr, cCount, ppIPropertyBagPtr); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), pguidVendor, dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(pIStream, in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(pIStream, in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), pguidVendor, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static int CreateComponentInfo(this ComPtr thisVtbl, out ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIInfo = default; + return @this->CreateComponentInfo(SilkMarshal.GuidPtrOf(), (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Span clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateComponentInfo(ref clsidComponent.GetPinnableReference(), ppIInfo); + } + + /// To be documented. + public static int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, ref ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateComponentInfo(ref clsidComponent, (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Span clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateComponentInfo(ref clsidComponent.GetPinnableReference(), ref ppIInfo); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIDecoder); + } + + /// To be documented. + public static int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ppIEncoder); + } + + /// To be documented. + public static int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIEncoder); + } + + /// To be documented. + public static int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIEncoder); + } + + /// To be documented. + public static int CreatePalette(this ComPtr thisVtbl, ref ComPtr ppIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreatePalette((IWICPalette**) ppIPalette.GetAddressOf()); + } + + /// To be documented. + public static int CreateFormatConverter(this ComPtr thisVtbl, ref ComPtr ppIFormatConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFormatConverter((IWICFormatConverter**) ppIFormatConverter.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapScaler(this ComPtr thisVtbl, ref ComPtr ppIBitmapScaler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapScaler((IWICBitmapScaler**) ppIBitmapScaler.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapClipper(this ComPtr thisVtbl, ref ComPtr ppIBitmapClipper) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapClipper((IWICBitmapClipper**) ppIBitmapClipper.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapFlipRotator(this ComPtr thisVtbl, ref ComPtr ppIBitmapFlipRotator) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFlipRotator((IWICBitmapFlipRotator**) ppIBitmapFlipRotator.GetAddressOf()); + } + + /// To be documented. + public static int CreateStream(this ComPtr thisVtbl, ref ComPtr ppIWICStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStream((IWICStream**) ppIWICStream.GetAddressOf()); + } + + /// To be documented. + public static int CreateColorContext(this ComPtr thisVtbl, ref ComPtr ppIWICColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateColorContext((IWICColorContext**) ppIWICColorContext.GetAddressOf()); + } + + /// To be documented. + public static int CreateColorTransformer(this ComPtr thisVtbl, ref ComPtr ppIWICColorTransform) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateColorTransformer((IWICColorTransform**) ppIWICColorTransform.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), option, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), option, ref ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource.GetPinnableReference(), option, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource.GetPinnableReference(), option, ref ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, Span pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource.GetPinnableReference(), x, y, width, height, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, Span pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource.GetPinnableReference(), x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette.GetPinnableReference(), options, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette.GetPinnableReference(), options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), hPalette, options, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), hPalette, options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), ref hPalette.GetPinnableReference(), options, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), ref hPalette.GetPinnableReference(), options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHICON(hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, Span hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHICON(ref hIcon.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHICON(ref hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, Span hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHICON(ref hIcon.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ComPtr pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ComPtr pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, Span pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder.GetPinnableReference(), ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, Span pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder.GetPinnableReference(), ref ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ComPtr pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ComPtr pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, Span pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder.GetPinnableReference(), ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, Span pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder.GetPinnableReference(), ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(ref guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(pIQueryReader, in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(pIQueryReader, in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), pguidVendor, ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader(ref pIQueryReader, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(guidMetadataFormat, pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(guidMetadataFormat, in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, dwOptions, pIStream, ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, dwOptions, pIStream, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ppIReader); + } + + /// To be documented. + public static int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static int CreateMetadataReader(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReader(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReader(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(guidContainerFormat, in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), pguidVendor, dwOptions, pIStream, ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), pguidVendor, dwOptions, pIStream, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), pguidVendor, dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ppIReader); + } + + /// To be documented. + public static int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Silk.NET.Core.Win32Extras.IStream* pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, pIStream, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ComPtr pIStream, ref IWICMetadataReader* ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, in pguidVendor, dwOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ppIReader); + } + + /// To be documented. + public static int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat, in pguidVendor, dwOptions, ref pIStream, (IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataReaderFromContainer(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwOptions, Span pIStream, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataReaderFromContainer(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwOptions, ref pIStream.GetPinnableReference(), ref ppIReader); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriter(guidMetadataFormat, pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), dwMetadataOptions, ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriter(guidMetadataFormat, in pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), dwMetadataOptions, ref ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, dwMetadataOptions, ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat, pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, dwMetadataOptions, ref ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwMetadataOptions, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwMetadataOptions, ppIWriter); + } + + /// To be documented. + public static int CreateMetadataWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwMetadataOptions, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat, in pguidVendor, dwMetadataOptions, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwMetadataOptions, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwMetadataOptions, ref ppIWriter); + } + + /// To be documented. + public static int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ComPtr pIReader, out ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIWriter = default; + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ComPtr pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, pguidVendor, ref ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriterFromReader(pIReader, in pguidVendor.GetPinnableReference(), ppIWriter); + } + + /// To be documented. + public static int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ComPtr pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, in pguidVendor, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, IWICMetadataReader* pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriterFromReader(pIReader, in pguidVendor.GetPinnableReference(), ref ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ComPtr pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataWriter* ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader((IWICMetadataReader*) pIReader.Handle, in pguidVendor, ref ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, Span pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriterFromReader(ref pIReader.GetPinnableReference(), pguidVendor, ppIWriter); + } + + /// To be documented. + public static int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader, out ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIWriter = default; + return @this->CreateMetadataWriterFromReader(ref pIReader, SilkMarshal.GuidPtrOf(), (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, Span pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriterFromReader(ref pIReader.GetPinnableReference(), pguidVendor, ref ppIWriter); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, Span pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriterFromReader(ref pIReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIWriter); + } + + /// To be documented. + public static int CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateMetadataWriterFromReader(ref pIReader, in pguidVendor, (IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateMetadataWriterFromReader(this ComPtr thisVtbl, Span pIReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateMetadataWriterFromReader(ref pIReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIWriter); + } + + /// To be documented. + public static int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, ComPtr pIBlockReader, ref ComPtr ppIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryReaderFromBlockReader((IWICMetadataBlockReader*) pIBlockReader.Handle, (IWICMetadataQueryReader**) ppIQueryReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, ComPtr pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryReaderFromBlockReader((IWICMetadataBlockReader*) pIBlockReader.Handle, ref ppIQueryReader); + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, Span pIBlockReader, IWICMetadataQueryReader** ppIQueryReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryReaderFromBlockReader(ref pIBlockReader.GetPinnableReference(), ppIQueryReader); + } + + /// To be documented. + public static int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, ref IWICMetadataBlockReader pIBlockReader, ref ComPtr ppIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryReaderFromBlockReader(ref pIBlockReader, (IWICMetadataQueryReader**) ppIQueryReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryReaderFromBlockReader(this ComPtr thisVtbl, Span pIBlockReader, ref IWICMetadataQueryReader* ppIQueryReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryReaderFromBlockReader(ref pIBlockReader.GetPinnableReference(), ref ppIQueryReader); + } + + /// To be documented. + public static int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, ComPtr pIBlockWriter, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromBlockWriter((IWICMetadataBlockWriter*) pIBlockWriter.Handle, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, ComPtr pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromBlockWriter((IWICMetadataBlockWriter*) pIBlockWriter.Handle, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, Span pIBlockWriter, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromBlockWriter(ref pIBlockWriter.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, ref IWICMetadataBlockWriter pIBlockWriter, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromBlockWriter(ref pIBlockWriter, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromBlockWriter(this ComPtr thisVtbl, Span pIBlockWriter, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromBlockWriter(ref pIBlockWriter.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, void* ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoderPropertyBag(ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Span ppropOptions, uint cCount, Silk.NET.Core.Native.IUnknown** ppIPropertyBag) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoderPropertyBag(ref ppropOptions.GetPinnableReference(), cCount, ppIPropertyBag); + } + + /// To be documented. + public static int CreateEncoderPropertyBag(this ComPtr thisVtbl, ref T0 ppropOptions, uint cCount, ref ComPtr ppIPropertyBag) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoderPropertyBag(ref ppropOptions, cCount, (Silk.NET.Core.Native.IUnknown**) ppIPropertyBag.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoderPropertyBag(this ComPtr thisVtbl, Span ppropOptions, uint cCount, ref Silk.NET.Core.Native.IUnknown* ppIPropertyBag) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoderPropertyBag(ref ppropOptions.GetPinnableReference(), cCount, ref ppIPropertyBag); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateComponentInfo(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateComponentInfo(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(ref guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(ref pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateMetadataWriterFromReader(this ComPtr thisVtbl, ComPtr pIReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateMetadataWriterFromReader(pIReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateMetadataWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataReader pIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateMetadataWriterFromReader(ref pIReader, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..18ebc5cfe0 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs @@ -0,0 +1,657 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICComponentInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs new file mode 100644 index 0000000000..d0e0f2a1b1 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs @@ -0,0 +1,179 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICDdsDecoderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetParameters(this ComPtr thisVtbl, WICDdsParameters* pParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + return ret; + } + + /// To be documented. + public static int GetParameters(this ComPtr thisVtbl, ref WICDdsParameters pParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICDdsParameters* pParametersPtr = &pParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFrame(this ComPtr thisVtbl, uint arrayIndex, uint mipLevel, uint sliceIndex, IWICBitmapFrameDecode** ppIBitmapFrame) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, arrayIndex, mipLevel, sliceIndex, ppIBitmapFrame); + return ret; + } + + /// To be documented. + public static unsafe int GetFrame(this ComPtr thisVtbl, uint arrayIndex, uint mipLevel, uint sliceIndex, ref IWICBitmapFrameDecode* ppIBitmapFrame) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode** ppIBitmapFramePtr = &ppIBitmapFrame) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, arrayIndex, mipLevel, sliceIndex, ppIBitmapFramePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetParameters(this ComPtr thisVtbl, Span pParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetParameters(ref pParameters.GetPinnableReference()); + } + + /// To be documented. + public static int GetFrame(this ComPtr thisVtbl, uint arrayIndex, uint mipLevel, uint sliceIndex, ref ComPtr ppIBitmapFrame) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetFrame(arrayIndex, mipLevel, sliceIndex, (IWICBitmapFrameDecode**) ppIBitmapFrame.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs new file mode 100644 index 0000000000..69617e7a7b --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs @@ -0,0 +1,595 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICDdsEncoderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int SetParameters(this ComPtr thisVtbl, WICDdsParameters* pParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + return ret; + } + + /// To be documented. + public static int SetParameters(this ComPtr thisVtbl, ref WICDdsParameters pParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICDdsParameters* pParametersPtr = &pParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetParameters(this ComPtr thisVtbl, WICDdsParameters* pParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParameters); + return ret; + } + + /// To be documented. + public static int GetParameters(this ComPtr thisVtbl, ref WICDdsParameters pParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICDdsParameters* pParametersPtr = &pParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParametersPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevel, pSliceIndex); + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevel, pSliceIndexPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevelPtr, pSliceIndex); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndex, pMipLevelPtr, pSliceIndexPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevel, pSliceIndex); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevel, pSliceIndexPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevelPtr, pSliceIndex); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncode, pArrayIndexPtr, pMipLevelPtr, pSliceIndexPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevel, pSliceIndex); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevel, pSliceIndexPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevelPtr, pSliceIndex); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndex, pMipLevelPtr, pSliceIndexPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevel, pSliceIndex); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevel, pSliceIndexPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevelPtr, pSliceIndex); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode** ppIFrameEncodePtr = &ppIFrameEncode) + { + fixed (uint* pArrayIndexPtr = &pArrayIndex) + { + fixed (uint* pMipLevelPtr = &pMipLevel) + { + fixed (uint* pSliceIndexPtr = &pSliceIndex) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, ppIFrameEncodePtr, pArrayIndexPtr, pMipLevelPtr, pSliceIndexPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int SetParameters(this ComPtr thisVtbl, Span pParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetParameters(ref pParameters.GetPinnableReference()); + } + + /// To be documented. + public static int GetParameters(this ComPtr thisVtbl, Span pParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetParameters(ref pParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, pMipLevel, pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, pArrayIndex, pMipLevel, ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, Span pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, pArrayIndex, ref pMipLevel.GetPinnableReference(), pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, ref pMipLevel, pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, uint* pArrayIndex, Span pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, pArrayIndex, ref pMipLevel.GetPinnableReference(), ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, uint* pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), pArrayIndex, ref pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Span pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), pMipLevel, pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, pMipLevel, pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Span pArrayIndex, uint* pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), pMipLevel, ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref uint pArrayIndex, uint* pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Span pArrayIndex, Span pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), ref pMipLevel.GetPinnableReference(), pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, uint* pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, ref pMipLevel, pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, IWICBitmapFrameEncode** ppIFrameEncode, Span pArrayIndex, Span pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), ref pMipLevel.GetPinnableReference(), ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static int CreateNewFrame(this ComPtr thisVtbl, ref ComPtr ppIFrameEncode, ref uint pArrayIndex, ref uint pMipLevel, ref uint pSliceIndex) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateNewFrame((IWICBitmapFrameEncode**) ppIFrameEncode.GetAddressOf(), ref pArrayIndex, ref pMipLevel, ref pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, uint* pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, pArrayIndex, pMipLevel, ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, Span pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, pArrayIndex, ref pMipLevel.GetPinnableReference(), pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, uint* pArrayIndex, Span pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, pArrayIndex, ref pMipLevel.GetPinnableReference(), ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Span pArrayIndex, uint* pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), pMipLevel, pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Span pArrayIndex, uint* pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), pMipLevel, ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Span pArrayIndex, Span pMipLevel, uint* pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), ref pMipLevel.GetPinnableReference(), pSliceIndex); + } + + /// To be documented. + public static unsafe int CreateNewFrame(this ComPtr thisVtbl, ref IWICBitmapFrameEncode* ppIFrameEncode, Span pArrayIndex, Span pMipLevel, Span pSliceIndex) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateNewFrame(ref ppIFrameEncode, ref pArrayIndex.GetPinnableReference(), ref pMipLevel.GetPinnableReference(), ref pSliceIndex.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs new file mode 100644 index 0000000000..f3364e1a87 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICDdsFormatInfo")] + public unsafe partial struct WICDdsFormatInfo + { + public WICDdsFormatInfo + ( + Silk.NET.DXGI.Format? dxgiFormat = null, + uint? bytesPerBlock = null, + uint? blockWidth = null, + uint? blockHeight = null + ) : this() + { + if (dxgiFormat is not null) + { + DxgiFormat = dxgiFormat.Value; + } + + if (bytesPerBlock is not null) + { + BytesPerBlock = bytesPerBlock.Value; + } + + if (blockWidth is not null) + { + BlockWidth = blockWidth.Value; + } + + if (blockHeight is not null) + { + BlockHeight = blockHeight.Value; + } + } + + + [NativeName("Type", "DXGI_FORMAT")] + [NativeName("Type.Name", "DXGI_FORMAT")] + [NativeName("Name", "DxgiFormat")] + public Silk.NET.DXGI.Format DxgiFormat; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "BytesPerBlock")] + public uint BytesPerBlock; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "BlockWidth")] + public uint BlockWidth; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "BlockHeight")] + public uint BlockHeight; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs new file mode 100644 index 0000000000..82394a8f17 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs @@ -0,0 +1,327 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICDdsFrameDecodeVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSizeInBlocks(this ComPtr thisVtbl, uint* pWidthInBlocks, uint* pHeightInBlocks) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocks, pHeightInBlocks); + return ret; + } + + /// To be documented. + public static unsafe int GetSizeInBlocks(this ComPtr thisVtbl, uint* pWidthInBlocks, ref uint pHeightInBlocks) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pHeightInBlocksPtr = &pHeightInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocks, pHeightInBlocksPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSizeInBlocks(this ComPtr thisVtbl, ref uint pWidthInBlocks, uint* pHeightInBlocks) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pWidthInBlocksPtr = &pWidthInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocksPtr, pHeightInBlocks); + } + return ret; + } + + /// To be documented. + public static int GetSizeInBlocks(this ComPtr thisVtbl, ref uint pWidthInBlocks, ref uint pHeightInBlocks) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pWidthInBlocksPtr = &pWidthInBlocks) + { + fixed (uint* pHeightInBlocksPtr = &pHeightInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pWidthInBlocksPtr, pHeightInBlocksPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFormatInfo(this ComPtr thisVtbl, WICDdsFormatInfo* pFormatInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfo); + return ret; + } + + /// To be documented. + public static int GetFormatInfo(this ComPtr thisVtbl, ref WICDdsFormatInfo pFormatInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICDdsFormatInfo* pFormatInfoPtr = &pFormatInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSizeInBlocks(this ComPtr thisVtbl, uint* pWidthInBlocks, Span pHeightInBlocks) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeInBlocks(pWidthInBlocks, ref pHeightInBlocks.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSizeInBlocks(this ComPtr thisVtbl, Span pWidthInBlocks, uint* pHeightInBlocks) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeInBlocks(ref pWidthInBlocks.GetPinnableReference(), pHeightInBlocks); + } + + /// To be documented. + public static int GetSizeInBlocks(this ComPtr thisVtbl, Span pWidthInBlocks, Span pHeightInBlocks) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeInBlocks(ref pWidthInBlocks.GetPinnableReference(), ref pHeightInBlocks.GetPinnableReference()); + } + + /// To be documented. + public static int GetFormatInfo(this ComPtr thisVtbl, Span pFormatInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFormatInfo(ref pFormatInfo.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyBlocks(prcBoundsInBlocks, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyBlocks(in prcBoundsInBlocks.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyBlocks(in prcBoundsInBlocks.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyBlocks(in prcBoundsInBlocks.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs new file mode 100644 index 0000000000..3536a61d40 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs @@ -0,0 +1,116 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICDdsParameters")] + public unsafe partial struct WICDdsParameters + { + public WICDdsParameters + ( + uint? width = null, + uint? height = null, + uint? depth = null, + uint? mipLevels = null, + uint? arraySize = null, + Silk.NET.DXGI.Format? dxgiFormat = null, + WICDdsDimension? dimension = null, + WICDdsAlphaMode? alphaMode = null + ) : this() + { + if (width is not null) + { + Width = width.Value; + } + + if (height is not null) + { + Height = height.Value; + } + + if (depth is not null) + { + Depth = depth.Value; + } + + if (mipLevels is not null) + { + MipLevels = mipLevels.Value; + } + + if (arraySize is not null) + { + ArraySize = arraySize.Value; + } + + if (dxgiFormat is not null) + { + DxgiFormat = dxgiFormat.Value; + } + + if (dimension is not null) + { + Dimension = dimension.Value; + } + + if (alphaMode is not null) + { + AlphaMode = alphaMode.Value; + } + } + + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Width")] + public uint Width; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Height")] + public uint Height; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Depth")] + public uint Depth; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "MipLevels")] + public uint MipLevels; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "ArraySize")] + public uint ArraySize; + + [NativeName("Type", "DXGI_FORMAT")] + [NativeName("Type.Name", "DXGI_FORMAT")] + [NativeName("Name", "DxgiFormat")] + public Silk.NET.DXGI.Format DxgiFormat; + + [NativeName("Type", "WICDdsDimension")] + [NativeName("Type.Name", "WICDdsDimension")] + [NativeName("Name", "Dimension")] + public WICDdsDimension Dimension; + + [NativeName("Type", "WICDdsAlphaMode")] + [NativeName("Type.Name", "WICDdsAlphaMode")] + [NativeName("Name", "AlphaMode")] + public WICDdsAlphaMode AlphaMode; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawNotificationCallbackVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawNotificationCallbackVtblExtensions.gen.cs new file mode 100644 index 0000000000..1068755712 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawNotificationCallbackVtblExtensions.gen.cs @@ -0,0 +1,130 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICDevelopRawNotificationCallbackVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int Notify(this ComPtr thisVtbl, uint NotificationMask) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, NotificationMask); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs new file mode 100644 index 0000000000..c77a44492a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs @@ -0,0 +1,1571 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICDevelopRawVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryReader(this ComPtr thisVtbl, IWICMetadataQueryReader** ppIMetadataQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReader); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader* ppIMetadataQueryReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader** ppIMetadataQueryReaderPtr = &ppIMetadataQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIMetadataQueryReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, uint* pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCount); + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, ref uint pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContexts, pcActualCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, uint* pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCount); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, ref uint pcActualCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextsPtr = &ppIColorContexts) + { + fixed (uint* pcActualCountPtr = &pcActualCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, ppIColorContextsPtr, pcActualCountPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetThumbnail(this ComPtr thisVtbl, IWICBitmapSource** ppIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnail); + return ret; + } + + /// To be documented. + public static unsafe int GetThumbnail(this ComPtr thisVtbl, ref IWICBitmapSource* ppIThumbnail) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppIThumbnailPtr = &ppIThumbnail) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIThumbnailPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, WICRawCapabilitiesInfo* pInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfo); + return ret; + } + + /// To be documented. + public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, ref WICRawCapabilitiesInfo pInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRawCapabilitiesInfo* pInfoPtr = &pInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfoPtr); + } + return ret; + } + + /// To be documented. + public static int LoadParameterSet(this ComPtr thisVtbl, WICRawParameterSet ParameterSet) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ParameterSet); + return ret; + } + + /// To be documented. + public static unsafe int GetCurrentParameterSet(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown** ppCurrentParameterSet) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSet); + return ret; + } + + /// To be documented. + public static unsafe int GetCurrentParameterSet(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown* ppCurrentParameterSet) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Native.IUnknown** ppCurrentParameterSetPtr = &ppCurrentParameterSet) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppCurrentParameterSetPtr); + } + return ret; + } + + /// To be documented. + public static int SetExposureCompensation(this ComPtr thisVtbl, double ev) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ev); + return ret; + } + + /// To be documented. + public static unsafe int GetExposureCompensation(this ComPtr thisVtbl, double* pEV) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pEV); + return ret; + } + + /// To be documented. + public static int GetExposureCompensation(this ComPtr thisVtbl, ref double pEV) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pEVPtr = &pEV) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pEVPtr); + } + return ret; + } + + /// To be documented. + public static int SetWhitePointRGB(this ComPtr thisVtbl, uint Red, uint Green, uint Blue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, Red, Green, Blue); + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, uint* pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreen, pBlue); + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, uint* pGreen, ref uint pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreen, pBluePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, ref uint pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pGreenPtr = &pGreen) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreenPtr, pBlue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, ref uint pGreen, ref uint pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pGreenPtr = &pGreen) + { + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRed, pGreenPtr, pBluePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, ref uint pRed, uint* pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreen, pBlue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, ref uint pRed, uint* pGreen, ref uint pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreen, pBluePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, ref uint pRed, ref uint pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + fixed (uint* pGreenPtr = &pGreen) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreenPtr, pBlue); + } + } + return ret; + } + + /// To be documented. + public static int GetWhitePointRGB(this ComPtr thisVtbl, ref uint pRed, ref uint pGreen, ref uint pBlue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pRedPtr = &pRed) + { + fixed (uint* pGreenPtr = &pGreen) + { + fixed (uint* pBluePtr = &pBlue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pRedPtr, pGreenPtr, pBluePtr); + } + } + } + return ret; + } + + /// To be documented. + public static int SetNamedWhitePoint(this ComPtr thisVtbl, WICNamedWhitePoint WhitePoint) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, WhitePoint); + return ret; + } + + /// To be documented. + public static unsafe int GetNamedWhitePoint(this ComPtr thisVtbl, WICNamedWhitePoint* pWhitePoint) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePoint); + return ret; + } + + /// To be documented. + public static int GetNamedWhitePoint(this ComPtr thisVtbl, ref WICNamedWhitePoint pWhitePoint) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICNamedWhitePoint* pWhitePointPtr = &pWhitePoint) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePointPtr); + } + return ret; + } + + /// To be documented. + public static int SetWhitePointKelvin(this ComPtr thisVtbl, uint WhitePointKelvin) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, WhitePointKelvin); + return ret; + } + + /// To be documented. + public static unsafe int GetWhitePointKelvin(this ComPtr thisVtbl, uint* pWhitePointKelvin) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pWhitePointKelvin); + return ret; + } + + /// To be documented. + public static int GetWhitePointKelvin(this ComPtr thisVtbl, ref uint pWhitePointKelvin) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pWhitePointKelvinPtr = &pWhitePointKelvin) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, pWhitePointKelvinPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, uint* pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTemp, pKelvinTempStepValue); + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, uint* pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTemp, pKelvinTempStepValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, ref uint pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTempPtr, pKelvinTempStepValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, ref uint pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTemp, pMaxKelvinTempPtr, pKelvinTempStepValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, ref uint pMinKelvinTemp, uint* pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTemp, pKelvinTempStepValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, ref uint pMinKelvinTemp, uint* pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTemp, pKelvinTempStepValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, ref uint pMinKelvinTemp, ref uint pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTempPtr, pKelvinTempStepValue); + } + } + return ret; + } + + /// To be documented. + public static int GetKelvinRangeInfo(this ComPtr thisVtbl, ref uint pMinKelvinTemp, ref uint pMaxKelvinTemp, ref uint pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pMinKelvinTempPtr = &pMinKelvinTemp) + { + fixed (uint* pMaxKelvinTempPtr = &pMaxKelvinTemp) + { + fixed (uint* pKelvinTempStepValuePtr = &pKelvinTempStepValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, pMinKelvinTempPtr, pMaxKelvinTempPtr, pKelvinTempStepValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static int SetContrast(this ComPtr thisVtbl, double Contrast) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, Contrast); + return ret; + } + + /// To be documented. + public static unsafe int GetContrast(this ComPtr thisVtbl, double* pContrast) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pContrast); + return ret; + } + + /// To be documented. + public static int GetContrast(this ComPtr thisVtbl, ref double pContrast) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pContrastPtr = &pContrast) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pContrastPtr); + } + return ret; + } + + /// To be documented. + public static int SetGamma(this ComPtr thisVtbl, double Gamma) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, Gamma); + return ret; + } + + /// To be documented. + public static unsafe int GetGamma(this ComPtr thisVtbl, double* pGamma) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, pGamma); + return ret; + } + + /// To be documented. + public static int GetGamma(this ComPtr thisVtbl, ref double pGamma) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pGammaPtr = &pGamma) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, pGammaPtr); + } + return ret; + } + + /// To be documented. + public static int SetSharpness(this ComPtr thisVtbl, double Sharpness) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, Sharpness); + return ret; + } + + /// To be documented. + public static unsafe int GetSharpness(this ComPtr thisVtbl, double* pSharpness) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pSharpness); + return ret; + } + + /// To be documented. + public static int GetSharpness(this ComPtr thisVtbl, ref double pSharpness) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pSharpnessPtr = &pSharpness) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pSharpnessPtr); + } + return ret; + } + + /// To be documented. + public static int SetSaturation(this ComPtr thisVtbl, double Saturation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[29])(@this, Saturation); + return ret; + } + + /// To be documented. + public static unsafe int GetSaturation(this ComPtr thisVtbl, double* pSaturation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, pSaturation); + return ret; + } + + /// To be documented. + public static int GetSaturation(this ComPtr thisVtbl, ref double pSaturation) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pSaturationPtr = &pSaturation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[30])(@this, pSaturationPtr); + } + return ret; + } + + /// To be documented. + public static int SetTint(this ComPtr thisVtbl, double Tint) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[31])(@this, Tint); + return ret; + } + + /// To be documented. + public static unsafe int GetTint(this ComPtr thisVtbl, double* pTint) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pTint); + return ret; + } + + /// To be documented. + public static int GetTint(this ComPtr thisVtbl, ref double pTint) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pTintPtr = &pTint) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[32])(@this, pTintPtr); + } + return ret; + } + + /// To be documented. + public static int SetNoiseReduction(this ComPtr thisVtbl, double NoiseReduction) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[33])(@this, NoiseReduction); + return ret; + } + + /// To be documented. + public static unsafe int GetNoiseReduction(this ComPtr thisVtbl, double* pNoiseReduction) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, pNoiseReduction); + return ret; + } + + /// To be documented. + public static int GetNoiseReduction(this ComPtr thisVtbl, ref double pNoiseReduction) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pNoiseReductionPtr = &pNoiseReduction) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[34])(@this, pNoiseReductionPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetDestinationColorContext(this ComPtr thisVtbl, IWICColorContext* pColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[35])(@this, pColorContext); + return ret; + } + + /// To be documented. + public static int SetDestinationColorContext(this ComPtr thisVtbl, ref IWICColorContext pColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext* pColorContextPtr = &pColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[35])(@this, pColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurve); + return ret; + } + + /// To be documented. + public static int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurvePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + return ret; + } + + /// To be documented. + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSize); + } + return ret; + } + + /// To be documented. + public static int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + { + fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSizePtr); + } + } + return ret; + } + + /// To be documented. + public static int SetRotation(this ComPtr thisVtbl, double Rotation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[38])(@this, Rotation); + return ret; + } + + /// To be documented. + public static unsafe int GetRotation(this ComPtr thisVtbl, double* pRotation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[39])(@this, pRotation); + return ret; + } + + /// To be documented. + public static int GetRotation(this ComPtr thisVtbl, ref double pRotation) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pRotationPtr = &pRotation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[39])(@this, pRotationPtr); + } + return ret; + } + + /// To be documented. + public static int SetRenderMode(this ComPtr thisVtbl, WICRawRenderMode RenderMode) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[40])(@this, RenderMode); + return ret; + } + + /// To be documented. + public static unsafe int GetRenderMode(this ComPtr thisVtbl, WICRawRenderMode* pRenderMode) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderMode); + return ret; + } + + /// To be documented. + public static int GetRenderMode(this ComPtr thisVtbl, ref WICRawRenderMode pRenderMode) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRawRenderMode* pRenderModePtr = &pRenderMode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderModePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetNotificationCallback(this ComPtr thisVtbl, IWICDevelopRawNotificationCallback* pCallback) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[42])(@this, pCallback); + return ret; + } + + /// To be documented. + public static int SetNotificationCallback(this ComPtr thisVtbl, ref IWICDevelopRawNotificationCallback pCallback) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICDevelopRawNotificationCallback* pCallbackPtr = &pCallback) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[42])(@this, pCallbackPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int GetMetadataQueryReader(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataQueryReader((IWICMetadataQueryReader**) ppIMetadataQueryReader.GetAddressOf()); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContexts, uint* pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), pcActualCount); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, IWICColorContext** ppIColorContexts, Span pcActualCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorContexts(cCount, ppIColorContexts, ref pcActualCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref ComPtr ppIColorContexts, ref uint pcActualCount) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContexts(cCount, (IWICColorContext**) ppIColorContexts.GetAddressOf(), ref pcActualCount); + } + + /// To be documented. + public static unsafe int GetColorContexts(this ComPtr thisVtbl, uint cCount, ref IWICColorContext* ppIColorContexts, Span pcActualCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorContexts(cCount, ref ppIColorContexts, ref pcActualCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetThumbnail(this ComPtr thisVtbl, ref ComPtr ppIThumbnail) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetThumbnail((IWICBitmapSource**) ppIThumbnail.GetAddressOf()); + } + + /// To be documented. + public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, Span pInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryRawCapabilitiesInfo(ref pInfo.GetPinnableReference()); + } + + /// To be documented. + public static int GetCurrentParameterSet(this ComPtr thisVtbl, ref ComPtr ppCurrentParameterSet) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetCurrentParameterSet((Silk.NET.Core.Native.IUnknown**) ppCurrentParameterSet.GetAddressOf()); + } + + /// To be documented. + public static int GetExposureCompensation(this ComPtr thisVtbl, Span pEV) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetExposureCompensation(ref pEV.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, uint* pGreen, Span pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(pRed, pGreen, ref pBlue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, Span pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(pRed, ref pGreen.GetPinnableReference(), pBlue); + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, uint* pRed, Span pGreen, Span pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(pRed, ref pGreen.GetPinnableReference(), ref pBlue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, Span pRed, uint* pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(ref pRed.GetPinnableReference(), pGreen, pBlue); + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, Span pRed, uint* pGreen, Span pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(ref pRed.GetPinnableReference(), pGreen, ref pBlue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetWhitePointRGB(this ComPtr thisVtbl, Span pRed, Span pGreen, uint* pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(ref pRed.GetPinnableReference(), ref pGreen.GetPinnableReference(), pBlue); + } + + /// To be documented. + public static int GetWhitePointRGB(this ComPtr thisVtbl, Span pRed, Span pGreen, Span pBlue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointRGB(ref pRed.GetPinnableReference(), ref pGreen.GetPinnableReference(), ref pBlue.GetPinnableReference()); + } + + /// To be documented. + public static int GetNamedWhitePoint(this ComPtr thisVtbl, Span pWhitePoint) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNamedWhitePoint(ref pWhitePoint.GetPinnableReference()); + } + + /// To be documented. + public static int GetWhitePointKelvin(this ComPtr thisVtbl, Span pWhitePointKelvin) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetWhitePointKelvin(ref pWhitePointKelvin.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, uint* pMaxKelvinTemp, Span pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(pMinKelvinTemp, pMaxKelvinTemp, ref pKelvinTempStepValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, Span pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(pMinKelvinTemp, ref pMaxKelvinTemp.GetPinnableReference(), pKelvinTempStepValue); + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, uint* pMinKelvinTemp, Span pMaxKelvinTemp, Span pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(pMinKelvinTemp, ref pMaxKelvinTemp.GetPinnableReference(), ref pKelvinTempStepValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, Span pMinKelvinTemp, uint* pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(ref pMinKelvinTemp.GetPinnableReference(), pMaxKelvinTemp, pKelvinTempStepValue); + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, Span pMinKelvinTemp, uint* pMaxKelvinTemp, Span pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(ref pMinKelvinTemp.GetPinnableReference(), pMaxKelvinTemp, ref pKelvinTempStepValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetKelvinRangeInfo(this ComPtr thisVtbl, Span pMinKelvinTemp, Span pMaxKelvinTemp, uint* pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(ref pMinKelvinTemp.GetPinnableReference(), ref pMaxKelvinTemp.GetPinnableReference(), pKelvinTempStepValue); + } + + /// To be documented. + public static int GetKelvinRangeInfo(this ComPtr thisVtbl, Span pMinKelvinTemp, Span pMaxKelvinTemp, Span pKelvinTempStepValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetKelvinRangeInfo(ref pMinKelvinTemp.GetPinnableReference(), ref pMaxKelvinTemp.GetPinnableReference(), ref pKelvinTempStepValue.GetPinnableReference()); + } + + /// To be documented. + public static int GetContrast(this ComPtr thisVtbl, Span pContrast) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContrast(ref pContrast.GetPinnableReference()); + } + + /// To be documented. + public static int GetGamma(this ComPtr thisVtbl, Span pGamma) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetGamma(ref pGamma.GetPinnableReference()); + } + + /// To be documented. + public static int GetSharpness(this ComPtr thisVtbl, Span pSharpness) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSharpness(ref pSharpness.GetPinnableReference()); + } + + /// To be documented. + public static int GetSaturation(this ComPtr thisVtbl, Span pSaturation) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSaturation(ref pSaturation.GetPinnableReference()); + } + + /// To be documented. + public static int GetTint(this ComPtr thisVtbl, Span pTint) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetTint(ref pTint.GetPinnableReference()); + } + + /// To be documented. + public static int GetNoiseReduction(this ComPtr thisVtbl, Span pNoiseReduction) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNoiseReduction(ref pNoiseReduction.GetPinnableReference()); + } + + /// To be documented. + public static int SetDestinationColorContext(this ComPtr thisVtbl, ComPtr pColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetDestinationColorContext((IWICColorContext*) pColorContext.Handle); + } + + /// To be documented. + public static int SetDestinationColorContext(this ComPtr thisVtbl, Span pColorContext) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetDestinationColorContext(ref pColorContext.GetPinnableReference()); + } + + /// To be documented. + public static int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetToneCurve(cbToneCurveSize, in pToneCurve.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetToneCurve(cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetToneCurve(cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), pcbActualToneCurveBufferSize); + } + + /// To be documented. + public static int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetToneCurve(cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), ref pcbActualToneCurveBufferSize.GetPinnableReference()); + } + + /// To be documented. + public static int GetRotation(this ComPtr thisVtbl, Span pRotation) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetRotation(ref pRotation.GetPinnableReference()); + } + + /// To be documented. + public static int GetRenderMode(this ComPtr thisVtbl, Span pRenderMode) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetRenderMode(ref pRenderMode.GetPinnableReference()); + } + + /// To be documented. + public static int SetNotificationCallback(this ComPtr thisVtbl, ComPtr pCallback) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetNotificationCallback((IWICDevelopRawNotificationCallback*) pCallback.Handle); + } + + /// To be documented. + public static int SetNotificationCallback(this ComPtr thisVtbl, Span pCallback) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetNotificationCallback(ref pCallback.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs new file mode 100644 index 0000000000..9ac64edc94 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICEnumMetadataItemVtblExtensions.gen.cs @@ -0,0 +1,528 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICEnumMetadataItemVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetched); + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValue, pceltFetchedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetched); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, ref T0 rgeltValue, ref uint pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltId, rgeltValuePtr, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetched); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetched); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, ref T0 rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchema, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetched); + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValue, pceltFetchedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetched); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, void* rgeltId, ref T1 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltId, rgeltValuePtr, pceltFetchedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetched); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, void* rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValue, pceltFetchedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetched); + } + } + } + return ret; + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, ref T0 rgeltSchema, ref T1 rgeltId, ref T2 rgeltValue, ref uint pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* rgeltSchemaPtr = &rgeltSchema) + { + fixed (void* rgeltIdPtr = &rgeltId) + { + fixed (void* rgeltValuePtr = &rgeltValue) + { + fixed (uint* pceltFetchedPtr = &pceltFetched) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, celt, rgeltSchemaPtr, rgeltIdPtr, rgeltValuePtr, pceltFetchedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static int Skip(this ComPtr thisVtbl, uint celt) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, celt); + return ret; + } + + /// To be documented. + public static int Reset(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, IWICEnumMetadataItem** ppIEnumMetadataItem) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataItem); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref IWICEnumMetadataItem* ppIEnumMetadataItem) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICEnumMetadataItem** ppIEnumMetadataItemPtr = &ppIEnumMetadataItem) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataItemPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, void* rgeltValue, Span pceltFetched) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, rgeltId, rgeltValue, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, rgeltId, ref rgeltValue.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, void* rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, rgeltId, ref rgeltValue.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, ref rgeltId.GetPinnableReference(), rgeltValue, pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, void* rgeltValue, Span pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, ref rgeltId.GetPinnableReference(), rgeltValue, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, ref rgeltId.GetPinnableReference(), ref rgeltValue.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, void* rgeltSchema, Span rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, rgeltSchema, ref rgeltId.GetPinnableReference(), ref rgeltValue.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), rgeltId, rgeltValue, pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, void* rgeltValue, Span pceltFetched) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), rgeltId, rgeltValue, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), rgeltId, ref rgeltValue.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, void* rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), rgeltId, ref rgeltValue.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, void* rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), ref rgeltId.GetPinnableReference(), rgeltValue, pceltFetched); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, void* rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), ref rgeltId.GetPinnableReference(), rgeltValue, ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Span rgeltValue, uint* pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), ref rgeltId.GetPinnableReference(), ref rgeltValue.GetPinnableReference(), pceltFetched); + } + + /// To be documented. + public static int Next(this ComPtr thisVtbl, uint celt, Span rgeltSchema, Span rgeltId, Span rgeltValue, Span pceltFetched) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Next(celt, ref rgeltSchema.GetPinnableReference(), ref rgeltId.GetPinnableReference(), ref rgeltValue.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppIEnumMetadataItem) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((IWICEnumMetadataItem**) ppIEnumMetadataItem.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFastMetadataEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFastMetadataEncoderVtblExtensions.gen.cs new file mode 100644 index 0000000000..f451085b3a --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFastMetadataEncoderVtblExtensions.gen.cs @@ -0,0 +1,159 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICFastMetadataEncoderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int Commit(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryWriter(this ComPtr thisVtbl, IWICMetadataQueryWriter** ppIMetadataQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIMetadataQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataQueryWriter(this ComPtr thisVtbl, ref IWICMetadataQueryWriter* ppIMetadataQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIMetadataQueryWriterPtr = &ppIMetadataQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIMetadataQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetMetadataQueryWriter(this ComPtr thisVtbl, ref ComPtr ppIMetadataQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataQueryWriter((IWICMetadataQueryWriter**) ppIMetadataQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..4f05c12960 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs @@ -0,0 +1,758 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICFormatConverterInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pPixelFormatGUIDs, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDs, pcActual); + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pPixelFormatGUIDs, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDs, pcActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pPixelFormatGUIDs, uint* pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatGUIDsPtr = &pPixelFormatGUIDs) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDsPtr, pcActual); + } + return ret; + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, ref Guid pPixelFormatGUIDs, ref uint pcActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatGUIDsPtr = &pPixelFormatGUIDs) + { + fixed (uint* pcActualPtr = &pcActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, cFormats, pPixelFormatGUIDsPtr, pcActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, IWICFormatConverter** ppIConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIConverter); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref IWICFormatConverter* ppIConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFormatConverter** ppIConverterPtr = &ppIConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIConverterPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Guid* pPixelFormatGUIDs, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, pPixelFormatGUIDs, ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pPixelFormatGUIDs, uint* pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pPixelFormatGUIDs.GetPinnableReference(), pcActual); + } + + /// To be documented. + public static int GetPixelFormats(this ComPtr thisVtbl, uint cFormats, Span pPixelFormatGUIDs, Span pcActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormats(cFormats, ref pPixelFormatGUIDs.GetPinnableReference(), ref pcActual.GetPinnableReference()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref ComPtr ppIConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((IWICFormatConverter**) ppIConverter.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs new file mode 100644 index 0000000000..d78ac603f1 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs @@ -0,0 +1,812 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICFormatConverterVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISourcePtr = &pISource) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormat, pfCanConvert); + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormat, pfCanConvertPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormatPtr, pfCanConvert); + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormat, dstPixelFormatPtr, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, ref Guid srcPixelFormat, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormat, pfCanConvert); + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, ref Guid srcPixelFormat, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormat, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, ref Guid srcPixelFormat, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormatPtr, pfCanConvert); + } + } + return ret; + } + + /// To be documented. + public static int CanConvert(this ComPtr thisVtbl, ref Guid srcPixelFormat, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* srcPixelFormatPtr = &srcPixelFormat) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, srcPixelFormatPtr, dstPixelFormatPtr, pfCanConvertPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pISource, dstFormat, dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pISource, ref dstFormat.GetPinnableReference(), dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(pISource, ref dstFormat.GetPinnableReference(), dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource*) pISource.Handle, ref dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pISource, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), dstFormat, dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), ref dstFormat.GetPinnableReference(), dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref pISource, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, Span pISource, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref pISource.GetPinnableReference(), ref dstFormat.GetPinnableReference(), dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, Guid* dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(srcPixelFormat, dstPixelFormat, ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, Span dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(srcPixelFormat, ref dstPixelFormat.GetPinnableReference(), pfCanConvert); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Guid* srcPixelFormat, Span dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(srcPixelFormat, ref dstPixelFormat.GetPinnableReference(), ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Span srcPixelFormat, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(ref srcPixelFormat.GetPinnableReference(), dstPixelFormat, pfCanConvert); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Span srcPixelFormat, Guid* dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(ref srcPixelFormat.GetPinnableReference(), dstPixelFormat, ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, Span srcPixelFormat, Span dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(ref srcPixelFormat.GetPinnableReference(), ref dstPixelFormat.GetPinnableReference(), pfCanConvert); + } + + /// To be documented. + public static int CanConvert(this ComPtr thisVtbl, Span srcPixelFormat, Span dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(ref srcPixelFormat.GetPinnableReference(), ref dstPixelFormat.GetPinnableReference(), ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs new file mode 100644 index 0000000000..388381a586 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs @@ -0,0 +1,709 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICImageEncoderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParameters); + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParametersPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParameters); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParameters); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + } + } + return ret; + } + + /// To be documented. + public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParameters); + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParametersPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParameters); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParameters); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + } + } + return ret; + } + + /// To be documented. + public static int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParameters); + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParametersPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParameters); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParameters); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParametersPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParameters); + } + } + return ret; + } + + /// To be documented. + public static int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) + { + fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) + { + fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParametersPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrame(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(pImage, pFrameEncode, in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrame(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(pImage, ref pFrameEncode.GetPinnableReference(), pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(pImage, ref pFrameEncode.GetPinnableReference(), in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(ref pImage.GetPinnableReference(), pFrameEncode, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrame(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(ref pImage.GetPinnableReference(), pFrameEncode, in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrame(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(ref pImage.GetPinnableReference(), ref pFrameEncode.GetPinnableReference(), pImageParameters); + } + + /// To be documented. + public static int WriteFrame(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrame(ref pImage.GetPinnableReference(), ref pFrameEncode.GetPinnableReference(), in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrameThumbnail(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(pImage, pFrameEncode, in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrameThumbnail(pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(pImage, ref pFrameEncode.GetPinnableReference(), pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(pImage, ref pFrameEncode.GetPinnableReference(), in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(ref pImage.GetPinnableReference(), pFrameEncode, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrameThumbnail(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(ref pImage.GetPinnableReference(), pFrameEncode, in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteFrameThumbnail(ref pImage, (IWICBitmapFrameEncode*) pFrameEncode.Handle, in pImageParameters); + } + + /// To be documented. + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(ref pImage.GetPinnableReference(), ref pFrameEncode.GetPinnableReference(), pImageParameters); + } + + /// To be documented. + public static int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteFrameThumbnail(ref pImage.GetPinnableReference(), ref pFrameEncode.GetPinnableReference(), in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteThumbnail(pImage, (IWICBitmapEncoder*) pEncoder.Handle, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(pImage, pEncoder, in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteThumbnail(pImage, (IWICBitmapEncoder*) pEncoder.Handle, in pImageParameters); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(pImage, ref pEncoder.GetPinnableReference(), pImageParameters); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(pImage, ref pEncoder.GetPinnableReference(), in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(ref pImage.GetPinnableReference(), pEncoder, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteThumbnail(ref pImage, (IWICBitmapEncoder*) pEncoder.Handle, pImageParameters); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(ref pImage.GetPinnableReference(), pEncoder, in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteThumbnail(ref pImage, (IWICBitmapEncoder*) pEncoder.Handle, in pImageParameters); + } + + /// To be documented. + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(ref pImage.GetPinnableReference(), ref pEncoder.GetPinnableReference(), pImageParameters); + } + + /// To be documented. + public static int WriteThumbnail(this ComPtr thisVtbl, Span pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteThumbnail(ref pImage.GetPinnableReference(), ref pEncoder.GetPinnableReference(), in pImageParameters.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs new file mode 100644 index 0000000000..34585ade64 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs @@ -0,0 +1,105 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICImageParameters")] + public unsafe partial struct WICImageParameters + { + public WICImageParameters + ( + Silk.NET.Direct2D.PixelFormat? pixelFormat = null, + float? dpiX = null, + float? dpiY = null, + float? top = null, + float? left = null, + uint? pixelWidth = null, + uint? pixelHeight = null + ) : this() + { + if (pixelFormat is not null) + { + PixelFormat = pixelFormat.Value; + } + + if (dpiX is not null) + { + DpiX = dpiX.Value; + } + + if (dpiY is not null) + { + DpiY = dpiY.Value; + } + + if (top is not null) + { + Top = top.Value; + } + + if (left is not null) + { + Left = left.Value; + } + + if (pixelWidth is not null) + { + PixelWidth = pixelWidth.Value; + } + + if (pixelHeight is not null) + { + PixelHeight = pixelHeight.Value; + } + } + + + [NativeName("Type", "D2D1_PIXEL_FORMAT")] + [NativeName("Type.Name", "D2D1_PIXEL_FORMAT")] + [NativeName("Name", "PixelFormat")] + public Silk.NET.Direct2D.PixelFormat PixelFormat; + + [NativeName("Type", "FLOAT")] + [NativeName("Type.Name", "FLOAT")] + [NativeName("Name", "DpiX")] + public float DpiX; + + [NativeName("Type", "FLOAT")] + [NativeName("Type.Name", "FLOAT")] + [NativeName("Name", "DpiY")] + public float DpiY; + + [NativeName("Type", "FLOAT")] + [NativeName("Type.Name", "FLOAT")] + [NativeName("Name", "Top")] + public float Top; + + [NativeName("Type", "FLOAT")] + [NativeName("Type.Name", "FLOAT")] + [NativeName("Name", "Left")] + public float Left; + + [NativeName("Type", "UINT32")] + [NativeName("Type.Name", "UINT32")] + [NativeName("Name", "PixelWidth")] + public uint PixelWidth; + + [NativeName("Type", "UINT32")] + [NativeName("Type.Name", "UINT32")] + [NativeName("Name", "PixelHeight")] + public uint PixelHeight; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs new file mode 100644 index 0000000000..b03c5db049 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs @@ -0,0 +1,2928 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICImagingFactory2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Guid* clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfo); + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Guid* clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfo); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreatePalette(this ComPtr thisVtbl, IWICPalette** ppIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalette); + return ret; + } + + /// To be documented. + public static unsafe int CreatePalette(this ComPtr thisVtbl, ref IWICPalette* ppIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette** ppIPalettePtr = &ppIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFormatConverter(this ComPtr thisVtbl, IWICFormatConverter** ppIFormatConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverter); + return ret; + } + + /// To be documented. + public static unsafe int CreateFormatConverter(this ComPtr thisVtbl, ref IWICFormatConverter* ppIFormatConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFormatConverter** ppIFormatConverterPtr = &ppIFormatConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapScaler(this ComPtr thisVtbl, IWICBitmapScaler** ppIBitmapScaler) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScaler); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapScaler(this ComPtr thisVtbl, ref IWICBitmapScaler* ppIBitmapScaler) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapScaler** ppIBitmapScalerPtr = &ppIBitmapScaler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScalerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapClipper(this ComPtr thisVtbl, IWICBitmapClipper** ppIBitmapClipper) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipper); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapClipper(this ComPtr thisVtbl, ref IWICBitmapClipper* ppIBitmapClipper) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapClipper** ppIBitmapClipperPtr = &ppIBitmapClipper) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipperPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFlipRotator(this ComPtr thisVtbl, IWICBitmapFlipRotator** ppIBitmapFlipRotator) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotator); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFlipRotator(this ComPtr thisVtbl, ref IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFlipRotator** ppIBitmapFlipRotatorPtr = &ppIBitmapFlipRotator) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotatorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, IWICStream** ppIWICStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStream); + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, ref IWICStream* ppIWICStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICStream** ppIWICStreamPtr = &ppIWICStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateColorContext(this ComPtr thisVtbl, IWICColorContext** ppIWICColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContext); + return ret; + } + + /// To be documented. + public static unsafe int CreateColorContext(this ComPtr thisVtbl, ref IWICColorContext* ppIWICColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIWICColorContextPtr = &ppIWICColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateColorTransformer(this ComPtr thisVtbl, IWICColorTransform** ppIWICColorTransform) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransform); + return ret; + } + + /// To be documented. + public static unsafe int CreateColorTransformer(this ComPtr thisVtbl, ref IWICColorTransform* ppIWICColorTransform) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorTransform** ppIWICColorTransformPtr = &ppIWICColorTransform) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransformPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentEnumerator(this ComPtr thisVtbl, uint componentTypes, uint options, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknown); + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentEnumerator(this ComPtr thisVtbl, uint componentTypes, uint options, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknownPtr = &ppIEnumUnknown) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, IWICBitmapDecoder* pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, IWICBitmapFrameDecode* pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Device* pD2DDevice, IWICImageEncoder** ppWICImageEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevice, ppWICImageEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Device* pD2DDevice, ref IWICImageEncoder* ppWICImageEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICImageEncoder** ppWICImageEncoderPtr = &ppWICImageEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevice, ppWICImageEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Device pD2DDevice, IWICImageEncoder** ppWICImageEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Device* pD2DDevicePtr = &pD2DDevice) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevicePtr, ppWICImageEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Device pD2DDevice, ref IWICImageEncoder* ppWICImageEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Direct2D.ID2D1Device* pD2DDevicePtr = &pD2DDevice) + { + fixed (IWICImageEncoder** ppWICImageEncoderPtr = &ppWICImageEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[28])(@this, pD2DDevicePtr, ppWICImageEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), pguidVendor, dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(pIStream, in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(pIStream, in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), pguidVendor, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static int CreateComponentInfo(this ComPtr thisVtbl, out ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIInfo = default; + return @this->CreateComponentInfo(SilkMarshal.GuidPtrOf(), (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Span clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateComponentInfo(ref clsidComponent.GetPinnableReference(), ppIInfo); + } + + /// To be documented. + public static int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, ref ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateComponentInfo(ref clsidComponent, (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Span clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateComponentInfo(ref clsidComponent.GetPinnableReference(), ref ppIInfo); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIDecoder); + } + + /// To be documented. + public static int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ppIEncoder); + } + + /// To be documented. + public static int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIEncoder); + } + + /// To be documented. + public static int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIEncoder); + } + + /// To be documented. + public static int CreatePalette(this ComPtr thisVtbl, ref ComPtr ppIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreatePalette((IWICPalette**) ppIPalette.GetAddressOf()); + } + + /// To be documented. + public static int CreateFormatConverter(this ComPtr thisVtbl, ref ComPtr ppIFormatConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFormatConverter((IWICFormatConverter**) ppIFormatConverter.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapScaler(this ComPtr thisVtbl, ref ComPtr ppIBitmapScaler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapScaler((IWICBitmapScaler**) ppIBitmapScaler.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapClipper(this ComPtr thisVtbl, ref ComPtr ppIBitmapClipper) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapClipper((IWICBitmapClipper**) ppIBitmapClipper.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapFlipRotator(this ComPtr thisVtbl, ref ComPtr ppIBitmapFlipRotator) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFlipRotator((IWICBitmapFlipRotator**) ppIBitmapFlipRotator.GetAddressOf()); + } + + /// To be documented. + public static int CreateStream(this ComPtr thisVtbl, ref ComPtr ppIWICStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStream((IWICStream**) ppIWICStream.GetAddressOf()); + } + + /// To be documented. + public static int CreateColorContext(this ComPtr thisVtbl, ref ComPtr ppIWICColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateColorContext((IWICColorContext**) ppIWICColorContext.GetAddressOf()); + } + + /// To be documented. + public static int CreateColorTransformer(this ComPtr thisVtbl, ref ComPtr ppIWICColorTransform) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateColorTransformer((IWICColorTransform**) ppIWICColorTransform.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), option, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), option, ref ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource.GetPinnableReference(), option, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource.GetPinnableReference(), option, ref ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, Span pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource.GetPinnableReference(), x, y, width, height, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, Span pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource.GetPinnableReference(), x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette.GetPinnableReference(), options, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette.GetPinnableReference(), options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), hPalette, options, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), hPalette, options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), ref hPalette.GetPinnableReference(), options, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), ref hPalette.GetPinnableReference(), options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHICON(hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, Span hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHICON(ref hIcon.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHICON(ref hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, Span hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHICON(ref hIcon.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ComPtr pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ComPtr pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, Span pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder.GetPinnableReference(), ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, Span pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder.GetPinnableReference(), ref ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ComPtr pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ComPtr pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, Span pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder.GetPinnableReference(), ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, Span pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder.GetPinnableReference(), ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(ref guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(pIQueryReader, in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(pIQueryReader, in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), pguidVendor, ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader(ref pIQueryReader, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Device* pD2DDevice, ref ComPtr ppWICImageEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateImageEncoder(pD2DDevice, (IWICImageEncoder**) ppWICImageEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, Span pD2DDevice, IWICImageEncoder** ppWICImageEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateImageEncoder(ref pD2DDevice.GetPinnableReference(), ppWICImageEncoder); + } + + /// To be documented. + public static int CreateImageEncoder(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Device pD2DDevice, ref ComPtr ppWICImageEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateImageEncoder(ref pD2DDevice, (IWICImageEncoder**) ppWICImageEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateImageEncoder(this ComPtr thisVtbl, Span pD2DDevice, ref IWICImageEncoder* ppWICImageEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateImageEncoder(ref pD2DDevice.GetPinnableReference(), ref ppWICImageEncoder); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateComponentInfo(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateComponentInfo(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(ref guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(ref pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs new file mode 100644 index 0000000000..b9ce325973 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs @@ -0,0 +1,2848 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICImagingFactoryVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFilenamePtr = &wzFilename) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + } + } + SilkMarshal.Free((nint)wzFilenamePtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Guid* clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfo); + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Guid* clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponent, ppIInfoPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfo); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* clsidComponentPtr = &clsidComponent) + { + fixed (IWICComponentInfo** ppIInfoPtr = &ppIInfo) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, clsidComponentPtr, ppIInfoPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendor, ppIDecoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormat, pguidVendorPtr, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendor, ppIDecoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIDecoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendor, ppIEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormat, pguidVendorPtr, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendor, ppIEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoder); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICBitmapEncoder** ppIEncoderPtr = &ppIEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, guidContainerFormatPtr, pguidVendorPtr, ppIEncoderPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreatePalette(this ComPtr thisVtbl, IWICPalette** ppIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalette); + return ret; + } + + /// To be documented. + public static unsafe int CreatePalette(this ComPtr thisVtbl, ref IWICPalette* ppIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette** ppIPalettePtr = &ppIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, ppIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFormatConverter(this ComPtr thisVtbl, IWICFormatConverter** ppIFormatConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverter); + return ret; + } + + /// To be documented. + public static unsafe int CreateFormatConverter(this ComPtr thisVtbl, ref IWICFormatConverter* ppIFormatConverter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFormatConverter** ppIFormatConverterPtr = &ppIFormatConverter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, ppIFormatConverterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapScaler(this ComPtr thisVtbl, IWICBitmapScaler** ppIBitmapScaler) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScaler); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapScaler(this ComPtr thisVtbl, ref IWICBitmapScaler* ppIBitmapScaler) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapScaler** ppIBitmapScalerPtr = &ppIBitmapScaler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, ppIBitmapScalerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapClipper(this ComPtr thisVtbl, IWICBitmapClipper** ppIBitmapClipper) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipper); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapClipper(this ComPtr thisVtbl, ref IWICBitmapClipper* ppIBitmapClipper) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapClipper** ppIBitmapClipperPtr = &ppIBitmapClipper) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIBitmapClipperPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFlipRotator(this ComPtr thisVtbl, IWICBitmapFlipRotator** ppIBitmapFlipRotator) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotator); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFlipRotator(this ComPtr thisVtbl, ref IWICBitmapFlipRotator* ppIBitmapFlipRotator) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFlipRotator** ppIBitmapFlipRotatorPtr = &ppIBitmapFlipRotator) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppIBitmapFlipRotatorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, IWICStream** ppIWICStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStream); + return ret; + } + + /// To be documented. + public static unsafe int CreateStream(this ComPtr thisVtbl, ref IWICStream* ppIWICStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICStream** ppIWICStreamPtr = &ppIWICStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, ppIWICStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateColorContext(this ComPtr thisVtbl, IWICColorContext** ppIWICColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContext); + return ret; + } + + /// To be documented. + public static unsafe int CreateColorContext(this ComPtr thisVtbl, ref IWICColorContext* ppIWICColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIWICColorContextPtr = &ppIWICColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, ppIWICColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateColorTransformer(this ComPtr thisVtbl, IWICColorTransform** ppIWICColorTransform) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransform); + return ret; + } + + /// To be documented. + public static unsafe int CreateColorTransformer(this ComPtr thisVtbl, ref IWICColorTransform* ppIWICColorTransform) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorTransform** ppIWICColorTransformPtr = &ppIWICColorTransform) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, ppIWICColorTransformPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSource, x, y, width, height, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pIBitmapSourcePtr, x, y, width, height, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBuffer, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmap); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pixelFormatPtr = &pixelFormat) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, uiWidth, uiHeight, pixelFormatPtr, cbStride, cbBufferSize, pbBufferPtr, ppIBitmapPtr); + } + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hBitmapPtr = &hBitmap) + { + fixed (void* hPalettePtr = &hPalette) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmap); + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIcon, ppIBitmapPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmap); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* hIconPtr = &hIcon) + { + fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[22])(@this, hIconPtr, ppIBitmapPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentEnumerator(this ComPtr thisVtbl, uint componentTypes, uint options, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknown); + return ret; + } + + /// To be documented. + public static unsafe int CreateComponentEnumerator(this ComPtr thisVtbl, uint componentTypes, uint options, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumUnknown) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumUnknownPtr = &ppIEnumUnknown) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, componentTypes, options, ppIEnumUnknownPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, IWICBitmapDecoder* pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, IWICBitmapDecoder* pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapDecoder* pIDecoderPtr = &pIDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[24])(@this, pIDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, IWICBitmapFrameDecode* pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoder); + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, IWICBitmapFrameDecode* pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoder, ppIFastEncoderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoder); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapFrameDecode* pIFrameDecoderPtr = &pIFrameDecoder) + { + fixed (IWICFastMetadataEncoder** ppIFastEncoderPtr = &ppIFastEncoder) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[25])(@this, pIFrameDecoderPtr, ppIFastEncoderPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormat, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidMetadataFormatPtr = &guidMetadataFormat) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[26])(@this, guidMetadataFormatPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendor, ppIQueryWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReader, pguidVendorPtr, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriter); + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendor, ppIQueryWriterPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriter); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataQueryReader* pIQueryReaderPtr = &pIQueryReader) + { + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + fixed (IWICMetadataQueryWriter** ppIQueryWriterPtr = &ppIQueryWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[27])(@this, pIQueryReaderPtr, pguidVendorPtr, ppIQueryWriterPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), pguidVendor, dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(in wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(in wzFilename.GetPinnableReference(), in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor, dwDesiredAccess, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFilename(wzFilename, in pguidVendor.GetPinnableReference(), dwDesiredAccess, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(pIStream, in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(pIStream, in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), pguidVendor, metadataOptions, ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), pguidVendor, metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromStream(ref pIStream, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromStream(ref pIStream.GetPinnableReference(), in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor.GetPinnableReference(), metadataOptions, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor, metadataOptions, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoderFromFileHandle(hFile, in pguidVendor.GetPinnableReference(), metadataOptions, ref ppIDecoder); + } + + /// To be documented. + public static int CreateComponentInfo(this ComPtr thisVtbl, out ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIInfo = default; + return @this->CreateComponentInfo(SilkMarshal.GuidPtrOf(), (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Span clsidComponent, IWICComponentInfo** ppIInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateComponentInfo(ref clsidComponent.GetPinnableReference(), ppIInfo); + } + + /// To be documented. + public static int CreateComponentInfo(this ComPtr thisVtbl, ref Guid clsidComponent, ref ComPtr ppIInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateComponentInfo(ref clsidComponent, (IWICComponentInfo**) ppIInfo.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateComponentInfo(this ComPtr thisVtbl, Span clsidComponent, ref IWICComponentInfo* ppIInfo) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateComponentInfo(ref clsidComponent.GetPinnableReference(), ref ppIInfo); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ppIDecoder); + } + + /// To be documented. + public static int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, out ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIDecoder = default; + return @this->CreateDecoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapDecoder** ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIDecoder); + } + + /// To be documented. + public static int CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateDecoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapDecoder**) ppIDecoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateDecoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapDecoder* ppIDecoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateDecoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIDecoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ppIEncoder); + } + + /// To be documented. + public static int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, out ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIEncoder = default; + return @this->CreateEncoder(ref guidContainerFormat, SilkMarshal.GuidPtrOf(), (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref ppIEncoder); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICBitmapEncoder** ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIEncoder); + } + + /// To be documented. + public static int CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateEncoder(ref guidContainerFormat, in pguidVendor, (IWICBitmapEncoder**) ppIEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateEncoder(this ComPtr thisVtbl, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICBitmapEncoder* ppIEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateEncoder(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIEncoder); + } + + /// To be documented. + public static int CreatePalette(this ComPtr thisVtbl, ref ComPtr ppIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreatePalette((IWICPalette**) ppIPalette.GetAddressOf()); + } + + /// To be documented. + public static int CreateFormatConverter(this ComPtr thisVtbl, ref ComPtr ppIFormatConverter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFormatConverter((IWICFormatConverter**) ppIFormatConverter.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapScaler(this ComPtr thisVtbl, ref ComPtr ppIBitmapScaler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapScaler((IWICBitmapScaler**) ppIBitmapScaler.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapClipper(this ComPtr thisVtbl, ref ComPtr ppIBitmapClipper) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapClipper((IWICBitmapClipper**) ppIBitmapClipper.GetAddressOf()); + } + + /// To be documented. + public static int CreateBitmapFlipRotator(this ComPtr thisVtbl, ref ComPtr ppIBitmapFlipRotator) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFlipRotator((IWICBitmapFlipRotator**) ppIBitmapFlipRotator.GetAddressOf()); + } + + /// To be documented. + public static int CreateStream(this ComPtr thisVtbl, ref ComPtr ppIWICStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateStream((IWICStream**) ppIWICStream.GetAddressOf()); + } + + /// To be documented. + public static int CreateColorContext(this ComPtr thisVtbl, ref ComPtr ppIWICColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateColorContext((IWICColorContext**) ppIWICColorContext.GetAddressOf()); + } + + /// To be documented. + public static int CreateColorTransformer(this ComPtr thisVtbl, ref ComPtr ppIWICColorTransform) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateColorTransformer((IWICColorTransform**) ppIWICColorTransform.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), option, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmap(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), option, ref ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource((IWICBitmapSource*) pIBitmapSource.Handle, option, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource.GetPinnableReference(), option, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource, option, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSource(ref pIBitmapSource.GetPinnableReference(), option, ref ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ComPtr pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect((IWICBitmapSource*) pIBitmapSource.Handle, x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, Span pIBitmapSource, uint x, uint y, uint width, uint height, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource.GetPinnableReference(), x, y, width, height, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromSourceRect(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, uint x, uint y, uint width, uint height, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource, x, y, width, height, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromSourceRect(this ComPtr thisVtbl, Span pIBitmapSource, uint x, uint y, uint width, uint height, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromSourceRect(ref pIBitmapSource.GetPinnableReference(), x, y, width, height, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, byte* pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, ref byte pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, ref pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, Span pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, IWICBitmap** ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat, cbStride, cbBufferSize, pbBuffer, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromMemory(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, ref IWICBitmap* ppIBitmap) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromMemory(uiWidth, uiHeight, ref pixelFormat.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette.GetPinnableReference(), options, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(hBitmap, ref hPalette.GetPinnableReference(), options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), hPalette, options, ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), hPalette, options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), ref hPalette.GetPinnableReference(), options, ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap, ref hPalette, options, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHBITMAP(ref hBitmap.GetPinnableReference(), ref hPalette.GetPinnableReference(), options, ref ppIBitmap); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, void* hIcon, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHICON(hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, Span hIcon, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHICON(ref hIcon.GetPinnableReference(), ppIBitmap); + } + + /// To be documented. + public static int CreateBitmapFromHICON(this ComPtr thisVtbl, ref T0 hIcon, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateBitmapFromHICON(ref hIcon, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateBitmapFromHICON(this ComPtr thisVtbl, Span hIcon, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateBitmapFromHICON(ref hIcon.GetPinnableReference(), ref ppIBitmap); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ComPtr pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ComPtr pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder((IWICBitmapDecoder*) pIDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, Span pIDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder.GetPinnableReference(), ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, ref IWICBitmapDecoder pIDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromDecoder(this ComPtr thisVtbl, Span pIDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromDecoder(ref pIDecoder.GetPinnableReference(), ref ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ComPtr pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ComPtr pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode((IWICBitmapFrameDecode*) pIFrameDecoder.Handle, ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, Span pIFrameDecoder, IWICFastMetadataEncoder** ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder.GetPinnableReference(), ppIFastEncoder); + } + + /// To be documented. + public static int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, ref IWICBitmapFrameDecode pIFrameDecoder, ref ComPtr ppIFastEncoder) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder, (IWICFastMetadataEncoder**) ppIFastEncoder.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateFastMetadataEncoderFromFrameDecode(this ComPtr thisVtbl, Span pIFrameDecoder, ref IWICFastMetadataEncoder* ppIFastEncoder) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateFastMetadataEncoderFromFrameDecode(ref pIFrameDecoder.GetPinnableReference(), ref ppIFastEncoder); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(guidMetadataFormat, in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriter(ref guidMetadataFormat, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriter(this ComPtr thisVtbl, Span guidMetadataFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriter(ref guidMetadataFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(pIQueryReader, in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, IWICMetadataQueryReader* pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(pIQueryReader, in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader((IWICMetadataQueryReader*) pIQueryReader.Handle, in pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), pguidVendor, ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, out ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppIQueryWriter = default; + return @this->CreateQueryWriterFromReader(ref pIQueryReader, SilkMarshal.GuidPtrOf(), (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), pguidVendor, ref ppIQueryWriter); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, IWICMetadataQueryWriter** ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ppIQueryWriter); + } + + /// To be documented. + public static int CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref ComPtr ppIQueryWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader, in pguidVendor, (IWICMetadataQueryWriter**) ppIQueryWriter.GetAddressOf()); + } + + /// To be documented. + public static unsafe int CreateQueryWriterFromReader(this ComPtr thisVtbl, Span pIQueryReader, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, ref IWICMetadataQueryWriter* ppIQueryWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CreateQueryWriterFromReader(ref pIQueryReader.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref ppIQueryWriter); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateComponentInfo(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateComponentInfo(out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateDecoder(this ComPtr thisVtbl, Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateDecoder(this ComPtr thisVtbl, ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateDecoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateEncoder(this ComPtr thisVtbl, Guid* guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateEncoder(this ComPtr thisVtbl, ref Guid guidContainerFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateEncoder(ref guidContainerFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static unsafe ComPtr CreateQueryWriter(this ComPtr thisVtbl, Guid* guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriter(this ComPtr thisVtbl, ref Guid guidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriter(ref guidMetadataFormat, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriterFromReader(this ComPtr thisVtbl, ComPtr pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + + /// To be documented. + public static ComPtr CreateQueryWriterFromReader(this ComPtr thisVtbl, ref IWICMetadataQueryReader pIQueryReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->CreateQueryWriterFromReader(ref pIQueryReader, out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs new file mode 100644 index 0000000000..6f6a76407f --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs @@ -0,0 +1,523 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICJpegFrameDecodeVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportIndexing(this ComPtr thisVtbl, int* pfIndexingSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfIndexingSupported); + return ret; + } + + /// To be documented. + public static int DoesSupportIndexing(this ComPtr thisVtbl, ref int pfIndexingSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfIndexingSupportedPtr = &pfIndexingSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pfIndexingSupportedPtr); + } + return ret; + } + + /// To be documented. + public static int SetIndexing(this ComPtr thisVtbl, WICJpegIndexingOptions options, uint horizontalIntervalSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, options, horizontalIntervalSize); + return ret; + } + + /// To be documented. + public static int ClearIndexing(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetAcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, scanIndex, tableIndex, pAcHuffmanTable); + return ret; + } + + /// To be documented. + public static int GetAcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegACHuffmanTable pAcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTablePtr = &pAcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, scanIndex, tableIndex, pAcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, scanIndex, tableIndex, pDcHuffmanTable); + return ret; + } + + /// To be documented. + public static int GetDcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegDCHuffmanTable pDcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTablePtr = &pDcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, scanIndex, tableIndex, pDcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetQuantizationTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, scanIndex, tableIndex, pQuantizationTable); + return ret; + } + + /// To be documented. + public static int GetQuantizationTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegQuantizationTable pQuantizationTable) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTablePtr = &pQuantizationTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, scanIndex, tableIndex, pQuantizationTablePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFrameHeader(this ComPtr thisVtbl, WICJpegFrameHeader* pFrameHeader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeader); + return ret; + } + + /// To be documented. + public static int GetFrameHeader(this ComPtr thisVtbl, ref WICJpegFrameHeader pFrameHeader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICJpegFrameHeader* pFrameHeaderPtr = &pFrameHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, WICJpegScanHeader* pScanHeader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeader); + return ret; + } + + /// To be documented. + public static int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, ref WICJpegScanHeader pScanHeader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICJpegScanHeader* pScanHeaderPtr = &pScanHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, byte* pbScanData, uint* pcbScanDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanData, pcbScanDataActual); + return ret; + } + + /// To be documented. + public static unsafe int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, byte* pbScanData, ref uint pcbScanDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbScanDataActualPtr = &pcbScanDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanData, pcbScanDataActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, ref byte pbScanData, uint* pcbScanDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbScanDataPtr = &pbScanData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActual); + } + return ret; + } + + /// To be documented. + public static int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, ref byte pbScanData, ref uint pcbScanDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbScanDataPtr = &pbScanData) + { + fixed (uint* pcbScanDataActualPtr = &pcbScanDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData, uint* pcbScanDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbScanDataPtr = (byte*) SilkMarshal.StringToPtr(pbScanData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActual); + SilkMarshal.Free((nint)pbScanDataPtr); + return ret; + } + + /// To be documented. + public static int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData, ref uint pcbScanDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbScanDataPtr = (byte*) SilkMarshal.StringToPtr(pbScanData, NativeStringEncoding.UTF8); + fixed (uint* pcbScanDataActualPtr = &pcbScanDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, scanIndex, scanOffset, cbScanData, pbScanDataPtr, pcbScanDataActualPtr); + } + SilkMarshal.Free((nint)pbScanDataPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, byte* pbStreamData, uint* pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamData, pcbStreamDataActual); + return ret; + } + + /// To be documented. + public static unsafe int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, byte* pbStreamData, ref uint pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbStreamDataActualPtr = &pcbStreamDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamData, pcbStreamDataActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, ref byte pbStreamData, uint* pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbStreamDataPtr = &pbStreamData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActual); + } + return ret; + } + + /// To be documented. + public static int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, ref byte pbStreamData, ref uint pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbStreamDataPtr = &pbStreamData) + { + fixed (uint* pcbStreamDataActualPtr = &pcbStreamDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbStreamData, uint* pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbStreamDataPtr = (byte*) SilkMarshal.StringToPtr(pbStreamData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActual); + SilkMarshal.Free((nint)pbStreamDataPtr); + return ret; + } + + /// To be documented. + public static int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbStreamData, ref uint pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbStreamDataPtr = (byte*) SilkMarshal.StringToPtr(pbStreamData, NativeStringEncoding.UTF8); + fixed (uint* pcbStreamDataActualPtr = &pcbStreamDataActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, streamOffset, cbStreamData, pbStreamDataPtr, pcbStreamDataActualPtr); + } + SilkMarshal.Free((nint)pbStreamDataPtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int DoesSupportIndexing(this ComPtr thisVtbl, Span pfIndexingSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportIndexing(ref pfIndexingSupported.GetPinnableReference()); + } + + /// To be documented. + public static int GetAcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Span pAcHuffmanTable) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAcHuffmanTable(scanIndex, tableIndex, ref pAcHuffmanTable.GetPinnableReference()); + } + + /// To be documented. + public static int GetDcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Span pDcHuffmanTable) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDcHuffmanTable(scanIndex, tableIndex, ref pDcHuffmanTable.GetPinnableReference()); + } + + /// To be documented. + public static int GetQuantizationTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Span pQuantizationTable) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetQuantizationTable(scanIndex, tableIndex, ref pQuantizationTable.GetPinnableReference()); + } + + /// To be documented. + public static int GetFrameHeader(this ComPtr thisVtbl, Span pFrameHeader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFrameHeader(ref pFrameHeader.GetPinnableReference()); + } + + /// To be documented. + public static int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, Span pScanHeader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetScanHeader(scanIndex, ref pScanHeader.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, byte* pbScanData, Span pcbScanDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyScan(scanIndex, scanOffset, cbScanData, pbScanData, ref pcbScanDataActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, Span pbScanData, uint* pcbScanDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyScan(scanIndex, scanOffset, cbScanData, ref pbScanData.GetPinnableReference(), pcbScanDataActual); + } + + /// To be documented. + public static int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, Span pbScanData, Span pcbScanDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyScan(scanIndex, scanOffset, cbScanData, ref pbScanData.GetPinnableReference(), ref pcbScanDataActual.GetPinnableReference()); + } + + /// To be documented. + public static int CopyScan(this ComPtr thisVtbl, uint scanIndex, uint scanOffset, uint cbScanData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData, Span pcbScanDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyScan(scanIndex, scanOffset, cbScanData, pbScanData, ref pcbScanDataActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, byte* pbStreamData, Span pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyMinimalStream(streamOffset, cbStreamData, pbStreamData, ref pcbStreamDataActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, Span pbStreamData, uint* pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyMinimalStream(streamOffset, cbStreamData, ref pbStreamData.GetPinnableReference(), pcbStreamDataActual); + } + + /// To be documented. + public static int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, Span pbStreamData, Span pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyMinimalStream(streamOffset, cbStreamData, ref pbStreamData.GetPinnableReference(), ref pcbStreamDataActual.GetPinnableReference()); + } + + /// To be documented. + public static int CopyMinimalStream(this ComPtr thisVtbl, uint streamOffset, uint cbStreamData, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbStreamData, Span pcbStreamDataActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyMinimalStream(streamOffset, cbStreamData, pbStreamData, ref pcbStreamDataActual.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameEncodeVtblExtensions.gen.cs new file mode 100644 index 0000000000..9c13cdbae6 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameEncodeVtblExtensions.gen.cs @@ -0,0 +1,248 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICJpegFrameEncodeVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetAcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, scanIndex, tableIndex, pAcHuffmanTable); + return ret; + } + + /// To be documented. + public static int GetAcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegACHuffmanTable pAcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.DXGI.JpegACHuffmanTable* pAcHuffmanTablePtr = &pAcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, scanIndex, tableIndex, pAcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, scanIndex, tableIndex, pDcHuffmanTable); + return ret; + } + + /// To be documented. + public static int GetDcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegDCHuffmanTable pDcHuffmanTable) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.DXGI.JpegDCHuffmanTable* pDcHuffmanTablePtr = &pDcHuffmanTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, scanIndex, tableIndex, pDcHuffmanTablePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetQuantizationTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTable) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, scanIndex, tableIndex, pQuantizationTable); + return ret; + } + + /// To be documented. + public static int GetQuantizationTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, ref Silk.NET.DXGI.JpegQuantizationTable pQuantizationTable) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.DXGI.JpegQuantizationTable* pQuantizationTablePtr = &pQuantizationTable) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, scanIndex, tableIndex, pQuantizationTablePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteScan(this ComPtr thisVtbl, uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] byte* pbScanData) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cbScanData, pbScanData); + return ret; + } + + /// To be documented. + public static int WriteScan(this ComPtr thisVtbl, uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in byte pbScanData) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbScanDataPtr = &pbScanData) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cbScanData, pbScanDataPtr); + } + return ret; + } + + /// To be documented. + public static int WriteScan(this ComPtr thisVtbl, uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbScanData) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbScanDataPtr = (byte*) SilkMarshal.StringToPtr(pbScanData, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cbScanData, pbScanDataPtr); + SilkMarshal.Free((nint)pbScanDataPtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetAcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Span pAcHuffmanTable) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAcHuffmanTable(scanIndex, tableIndex, ref pAcHuffmanTable.GetPinnableReference()); + } + + /// To be documented. + public static int GetDcHuffmanTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Span pDcHuffmanTable) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDcHuffmanTable(scanIndex, tableIndex, ref pDcHuffmanTable.GetPinnableReference()); + } + + /// To be documented. + public static int GetQuantizationTable(this ComPtr thisVtbl, uint scanIndex, uint tableIndex, Span pQuantizationTable) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetQuantizationTable(scanIndex, tableIndex, ref pQuantizationTable.GetPinnableReference()); + } + + /// To be documented. + public static int WriteScan(this ComPtr thisVtbl, uint cbScanData, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pbScanData) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteScan(cbScanData, in pbScanData.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs new file mode 100644 index 0000000000..8e2aca1e85 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs @@ -0,0 +1,116 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegFrameHeader")] + public unsafe partial struct WICJpegFrameHeader + { + public WICJpegFrameHeader + ( + uint? width = null, + uint? height = null, + WICJpegTransferMatrix? transferMatrix = null, + WICJpegScanType? scanType = null, + uint? cComponents = null, + uint? componentIdentifiers = null, + uint? sampleFactors = null, + uint? quantizationTableIndices = null + ) : this() + { + if (width is not null) + { + Width = width.Value; + } + + if (height is not null) + { + Height = height.Value; + } + + if (transferMatrix is not null) + { + TransferMatrix = transferMatrix.Value; + } + + if (scanType is not null) + { + ScanType = scanType.Value; + } + + if (cComponents is not null) + { + CComponents = cComponents.Value; + } + + if (componentIdentifiers is not null) + { + ComponentIdentifiers = componentIdentifiers.Value; + } + + if (sampleFactors is not null) + { + SampleFactors = sampleFactors.Value; + } + + if (quantizationTableIndices is not null) + { + QuantizationTableIndices = quantizationTableIndices.Value; + } + } + + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Width")] + public uint Width; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "Height")] + public uint Height; + + [NativeName("Type", "WICJpegTransferMatrix")] + [NativeName("Type.Name", "WICJpegTransferMatrix")] + [NativeName("Name", "TransferMatrix")] + public WICJpegTransferMatrix TransferMatrix; + + [NativeName("Type", "WICJpegScanType")] + [NativeName("Type.Name", "WICJpegScanType")] + [NativeName("Name", "ScanType")] + public WICJpegScanType ScanType; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "cComponents")] + public uint CComponents; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "ComponentIdentifiers")] + public uint ComponentIdentifiers; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "SampleFactors")] + public uint SampleFactors; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "QuantizationTableIndices")] + public uint QuantizationTableIndices; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs new file mode 100644 index 0000000000..5af9f7f5e3 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs @@ -0,0 +1,116 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICJpegScanHeader")] + public unsafe partial struct WICJpegScanHeader + { + public WICJpegScanHeader + ( + uint? cComponents = null, + uint? restartInterval = null, + uint? componentSelectors = null, + uint? huffmanTableIndices = null, + byte? startSpectralSelection = null, + byte? endSpectralSelection = null, + byte? successiveApproximationHigh = null, + byte? successiveApproximationLow = null + ) : this() + { + if (cComponents is not null) + { + CComponents = cComponents.Value; + } + + if (restartInterval is not null) + { + RestartInterval = restartInterval.Value; + } + + if (componentSelectors is not null) + { + ComponentSelectors = componentSelectors.Value; + } + + if (huffmanTableIndices is not null) + { + HuffmanTableIndices = huffmanTableIndices.Value; + } + + if (startSpectralSelection is not null) + { + StartSpectralSelection = startSpectralSelection.Value; + } + + if (endSpectralSelection is not null) + { + EndSpectralSelection = endSpectralSelection.Value; + } + + if (successiveApproximationHigh is not null) + { + SuccessiveApproximationHigh = successiveApproximationHigh.Value; + } + + if (successiveApproximationLow is not null) + { + SuccessiveApproximationLow = successiveApproximationLow.Value; + } + } + + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "cComponents")] + public uint CComponents; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "RestartInterval")] + public uint RestartInterval; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "ComponentSelectors")] + public uint ComponentSelectors; + + [NativeName("Type", "DWORD")] + [NativeName("Type.Name", "DWORD")] + [NativeName("Name", "HuffmanTableIndices")] + public uint HuffmanTableIndices; + + [NativeName("Type", "BYTE")] + [NativeName("Type.Name", "BYTE")] + [NativeName("Name", "StartSpectralSelection")] + public byte StartSpectralSelection; + + [NativeName("Type", "BYTE")] + [NativeName("Type.Name", "BYTE")] + [NativeName("Name", "EndSpectralSelection")] + public byte EndSpectralSelection; + + [NativeName("Type", "BYTE")] + [NativeName("Type.Name", "BYTE")] + [NativeName("Name", "SuccessiveApproximationHigh")] + public byte SuccessiveApproximationHigh; + + [NativeName("Type", "BYTE")] + [NativeName("Type.Name", "BYTE")] + [NativeName("Name", "SuccessiveApproximationLow")] + public byte SuccessiveApproximationLow; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockReaderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockReaderVtblExtensions.gen.cs new file mode 100644 index 0000000000..a2e08eb73b --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockReaderVtblExtensions.gen.cs @@ -0,0 +1,229 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataBlockReaderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCount(this ComPtr thisVtbl, uint* pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCount); + return ret; + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, ref uint pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetReaderByIndex(this ComPtr thisVtbl, uint nIndex, IWICMetadataReader** ppIMetadataReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReader); + return ret; + } + + /// To be documented. + public static unsafe int GetReaderByIndex(this ComPtr thisVtbl, uint nIndex, ref IWICMetadataReader* ppIMetadataReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader** ppIMetadataReaderPtr = &ppIMetadataReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, Span pcCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCount(ref pcCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetReaderByIndex(this ComPtr thisVtbl, uint nIndex, ref ComPtr ppIMetadataReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetReaderByIndex(nIndex, (IWICMetadataReader**) ppIMetadataReader.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockWriterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockWriterVtblExtensions.gen.cs new file mode 100644 index 0000000000..9461e4afbd --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataBlockWriterVtblExtensions.gen.cs @@ -0,0 +1,378 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataBlockWriterVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCount(this ComPtr thisVtbl, uint* pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCount); + return ret; + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, ref uint pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetReaderByIndex(this ComPtr thisVtbl, uint nIndex, IWICMetadataReader** ppIMetadataReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReader); + return ret; + } + + /// To be documented. + public static unsafe int GetReaderByIndex(this ComPtr thisVtbl, uint nIndex, ref IWICMetadataReader* ppIMetadataReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader** ppIMetadataReaderPtr = &ppIMetadataReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nIndex, ppIMetadataReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IEnumUnknown* ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumUnknown** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromBlockReader(this ComPtr thisVtbl, IWICMetadataBlockReader* pIMDBlockReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIMDBlockReader); + return ret; + } + + /// To be documented. + public static int InitializeFromBlockReader(this ComPtr thisVtbl, ref IWICMetadataBlockReader pIMDBlockReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataBlockReader* pIMDBlockReaderPtr = &pIMDBlockReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pIMDBlockReaderPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetWriterByIndex(this ComPtr thisVtbl, uint nIndex, IWICMetadataWriter** ppIMetadataWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, nIndex, ppIMetadataWriter); + return ret; + } + + /// To be documented. + public static unsafe int GetWriterByIndex(this ComPtr thisVtbl, uint nIndex, ref IWICMetadataWriter* ppIMetadataWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataWriter** ppIMetadataWriterPtr = &ppIMetadataWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, nIndex, ppIMetadataWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int AddWriter(this ComPtr thisVtbl, IWICMetadataWriter* pIMetadataWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIMetadataWriter); + return ret; + } + + /// To be documented. + public static int AddWriter(this ComPtr thisVtbl, ref IWICMetadataWriter pIMetadataWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataWriter* pIMetadataWriterPtr = &pIMetadataWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIMetadataWriterPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetWriterByIndex(this ComPtr thisVtbl, uint nIndex, IWICMetadataWriter* pIMetadataWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pIMetadataWriter); + return ret; + } + + /// To be documented. + public static int SetWriterByIndex(this ComPtr thisVtbl, uint nIndex, ref IWICMetadataWriter pIMetadataWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataWriter* pIMetadataWriterPtr = &pIMetadataWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pIMetadataWriterPtr); + } + return ret; + } + + /// To be documented. + public static int RemoveWriterByIndex(this ComPtr thisVtbl, uint nIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, nIndex); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, Span pcCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCount(ref pcCount.GetPinnableReference()); + } + + /// To be documented. + public static int GetReaderByIndex(this ComPtr thisVtbl, uint nIndex, ref ComPtr ppIMetadataReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetReaderByIndex(nIndex, (IWICMetadataReader**) ppIMetadataReader.GetAddressOf()); + } + + /// To be documented. + public static int InitializeFromBlockReader(this ComPtr thisVtbl, ComPtr pIMDBlockReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->InitializeFromBlockReader((IWICMetadataBlockReader*) pIMDBlockReader.Handle); + } + + /// To be documented. + public static int InitializeFromBlockReader(this ComPtr thisVtbl, Span pIMDBlockReader) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromBlockReader(ref pIMDBlockReader.GetPinnableReference()); + } + + /// To be documented. + public static int GetWriterByIndex(this ComPtr thisVtbl, uint nIndex, ref ComPtr ppIMetadataWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetWriterByIndex(nIndex, (IWICMetadataWriter**) ppIMetadataWriter.GetAddressOf()); + } + + /// To be documented. + public static int AddWriter(this ComPtr thisVtbl, ComPtr pIMetadataWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->AddWriter((IWICMetadataWriter*) pIMetadataWriter.Handle); + } + + /// To be documented. + public static int AddWriter(this ComPtr thisVtbl, Span pIMetadataWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->AddWriter(ref pIMetadataWriter.GetPinnableReference()); + } + + /// To be documented. + public static int SetWriterByIndex(this ComPtr thisVtbl, uint nIndex, ComPtr pIMetadataWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SetWriterByIndex(nIndex, (IWICMetadataWriter*) pIMetadataWriter.Handle); + } + + /// To be documented. + public static int SetWriterByIndex(this ComPtr thisVtbl, uint nIndex, Span pIMetadataWriter) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetWriterByIndex(nIndex, ref pIMetadataWriter.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..b186974b3f --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs @@ -0,0 +1,1055 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataHandlerInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataFormat(this ComPtr thisVtbl, Guid* pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, ref Guid pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, ref Guid pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, ref Guid pguidContainerFormats, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int DoesRequireFullStream(this ComPtr thisVtbl, int* pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStream); + return ret; + } + + /// To be documented. + public static int DoesRequireFullStream(this ComPtr thisVtbl, ref int pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfRequiresFullStreamPtr = &pfRequiresFullStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportPadding(this ComPtr thisVtbl, int* pfSupportsPadding) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPadding); + return ret; + } + + /// To be documented. + public static int DoesSupportPadding(this ComPtr thisVtbl, ref int pfSupportsPadding) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportsPaddingPtr = &pfSupportsPadding) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPaddingPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesRequireFixedSize(this ComPtr thisVtbl, int* pfFixedSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSize); + return ret; + } + + /// To be documented. + public static int DoesRequireFixedSize(this ComPtr thisVtbl, ref int pfFixedSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfFixedSizePtr = &pfFixedSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSizePtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, Span pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataFormat(ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, pguidContainerFormats, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Span pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, ref pguidContainerFormats.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Span pguidContainerFormats, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, ref pguidContainerFormats.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int DoesRequireFullStream(this ComPtr thisVtbl, Span pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesRequireFullStream(ref pfRequiresFullStream.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportPadding(this ComPtr thisVtbl, Span pfSupportsPadding) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportPadding(ref pfSupportsPadding.GetPinnableReference()); + } + + /// To be documented. + public static int DoesRequireFixedSize(this ComPtr thisVtbl, Span pfFixedSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesRequireFixedSize(ref pfFixedSize.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs new file mode 100644 index 0000000000..b2116eae43 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICMetadataHeader")] + public unsafe partial struct WICMetadataHeader + { + public WICMetadataHeader + ( + ulong? position = null, + uint? length = null, + byte* header = null, + ulong? dataOffset = null + ) : this() + { + if (position is not null) + { + Position = position.Value; + } + + if (length is not null) + { + Length = length.Value; + } + + if (header is not null) + { + Header = header; + } + + if (dataOffset is not null) + { + DataOffset = dataOffset.Value; + } + } + + + [NativeName("Type", "ULARGE_INTEGER")] + [NativeName("Type.Name", "ULARGE_INTEGER")] + [NativeName("Name", "Position")] + public ulong Position; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "Length")] + public uint Length; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "Header")] + public byte* Header; + + [NativeName("Type", "ULARGE_INTEGER")] + [NativeName("Type.Name", "ULARGE_INTEGER")] + [NativeName("Name", "DataOffset")] + public ulong DataOffset; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs new file mode 100644 index 0000000000..9c646f64d4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs @@ -0,0 +1,83 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICMetadataPattern")] + public unsafe partial struct WICMetadataPattern + { + public WICMetadataPattern + ( + ulong? position = null, + uint? length = null, + byte* pattern = null, + byte* mask = null, + ulong? dataOffset = null + ) : this() + { + if (position is not null) + { + Position = position.Value; + } + + if (length is not null) + { + Length = length.Value; + } + + if (pattern is not null) + { + Pattern = pattern; + } + + if (mask is not null) + { + Mask = mask; + } + + if (dataOffset is not null) + { + DataOffset = dataOffset.Value; + } + } + + + [NativeName("Type", "ULARGE_INTEGER")] + [NativeName("Type.Name", "ULARGE_INTEGER")] + [NativeName("Name", "Position")] + public ulong Position; + + [NativeName("Type", "ULONG")] + [NativeName("Type.Name", "ULONG")] + [NativeName("Name", "Length")] + public uint Length; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "Pattern")] + public byte* Pattern; + + [NativeName("Type", "BYTE *")] + [NativeName("Type.Name", "BYTE *")] + [NativeName("Name", "Mask")] + public byte* Mask; + + [NativeName("Type", "ULARGE_INTEGER")] + [NativeName("Type.Name", "ULARGE_INTEGER")] + [NativeName("Name", "DataOffset")] + public ulong DataOffset; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs new file mode 100644 index 0000000000..e9f9ce73d4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryReaderVtblExtensions.gen.cs @@ -0,0 +1,381 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataQueryReaderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, char* wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLength); + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, char* wzNamespace, ref uint pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLengthPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, ref char wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + } + return ret; + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, ref char wzNamespace, ref uint pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, ref uint pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IEnumString** ppIEnumString) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumString); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IEnumString* ppIEnumString) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumString** ppIEnumStringPtr = &ppIEnumString) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumStringPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, char* wzNamespace, Span pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, wzNamespace, ref pcchActualLength.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, Span wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, ref wzNamespace.GetPinnableReference(), pcchActualLength); + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, Span wzNamespace, Span pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, ref wzNamespace.GetPinnableReference(), ref pcchActualLength.GetPinnableReference()); + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, Span pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, wzNamespace, ref pcchActualLength.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(wzName, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(in wzName.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(in wzName.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(wzName, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs new file mode 100644 index 0000000000..d6d82ca358 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataQueryWriterVtblExtensions.gen.cs @@ -0,0 +1,526 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataQueryWriterVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormat(this ComPtr thisVtbl, Guid* pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormat); + return ret; + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, ref Guid pguidContainerFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatPtr = &pguidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidContainerFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, char* wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLength); + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, char* wzNamespace, ref uint pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespace, pcchActualLengthPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, ref char wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + } + return ret; + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, ref char wzNamespace, ref uint pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamespacePtr = &wzNamespace) + { + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLength); + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, ref uint pcchActualLength) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamespacePtr = (byte*) SilkMarshal.StringToPtr(wzNamespace, NativeStringEncoding.UTF8); + fixed (uint* pcchActualLengthPtr = &pcchActualLength) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, cchMaxLength, wzNamespacePtr, pcchActualLengthPtr); + } + SilkMarshal.Free((nint)wzNamespacePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzName, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValue); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, wzNamePtr, pvarValuePtr); + } + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IEnumString** ppIEnumString) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumString); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IEnumString* ppIEnumString) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IEnumString** ppIEnumStringPtr = &ppIEnumString) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, ppIEnumStringPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzName, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValue); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, wzNamePtr, pvarValuePtr); + } + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int RemoveMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, wzName); + return ret; + } + + /// To be documented. + public static int RemoveMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzNamePtr = &wzName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, wzNamePtr); + } + return ret; + } + + /// To be documented. + public static int RemoveMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzNamePtr = (byte*) SilkMarshal.StringToPtr(wzName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, wzNamePtr); + SilkMarshal.Free((nint)wzNamePtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetContainerFormat(this ComPtr thisVtbl, Span pguidContainerFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormat(ref pguidContainerFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, char* wzNamespace, Span pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, wzNamespace, ref pcchActualLength.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, Span wzNamespace, uint* pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, ref wzNamespace.GetPinnableReference(), pcchActualLength); + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, Span wzNamespace, Span pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, ref wzNamespace.GetPinnableReference(), ref pcchActualLength.GetPinnableReference()); + } + + /// To be documented. + public static int GetLocation(this ComPtr thisVtbl, uint cchMaxLength, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzNamespace, Span pcchActualLength) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLocation(cchMaxLength, wzNamespace, ref pcchActualLength.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(wzName, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, void* pvarValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(in wzName.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(in wzName.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataByName(wzName, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetMetadataByName(wzName, in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetMetadataByName(in wzName.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetMetadataByName(in wzName.GetPinnableReference(), in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int SetMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzName, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetMetadataByName(wzName, in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int RemoveMetadataByName(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RemoveMetadataByName(in wzName.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..e6805c9f68 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs @@ -0,0 +1,1640 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataReaderInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataFormat(this ComPtr thisVtbl, Guid* pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, ref Guid pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, ref Guid pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, ref Guid pguidContainerFormats, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int DoesRequireFullStream(this ComPtr thisVtbl, int* pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStream); + return ret; + } + + /// To be documented. + public static int DoesRequireFullStream(this ComPtr thisVtbl, ref int pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfRequiresFullStreamPtr = &pfRequiresFullStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportPadding(this ComPtr thisVtbl, int* pfSupportsPadding) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPadding); + return ret; + } + + /// To be documented. + public static int DoesSupportPadding(this ComPtr thisVtbl, ref int pfSupportsPadding) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportsPaddingPtr = &pfSupportsPadding) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPaddingPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesRequireFixedSize(this ComPtr thisVtbl, int* pfFixedSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSize); + return ret; + } + + /// To be documented. + public static int DoesRequireFixedSize(this ComPtr thisVtbl, ref int pfFixedSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfFixedSizePtr = &pfFixedSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActual); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActual); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActual); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActual); + } + } + } + return ret; + } + + /// To be documented. + public static int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataPattern* pPatternPtr = &pPattern) + { + fixed (uint* pcCountPtr = &pcCount) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStream, pfMatches); + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStream, pfMatchesPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStreamPtr, pfMatches); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormat, pIStreamPtr, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, ref Guid guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStream, pfMatches); + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, ref Guid guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStream, pfMatchesPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, ref Guid guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStreamPtr, pfMatches); + } + } + return ret; + } + + /// To be documented. + public static int MatchesPattern(this ComPtr thisVtbl, ref Guid guidContainerFormat, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref int pfMatches) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (int* pfMatchesPtr = &pfMatches) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, guidContainerFormatPtr, pIStreamPtr, pfMatchesPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, IWICMetadataReader** ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, ppIReader); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref IWICMetadataReader* ppIReader) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataReader** ppIReaderPtr = &ppIReader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[20])(@this, ppIReaderPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, Span pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataFormat(ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, pguidContainerFormats, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Span pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, ref pguidContainerFormats.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Span pguidContainerFormats, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, ref pguidContainerFormats.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int DoesRequireFullStream(this ComPtr thisVtbl, Span pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesRequireFullStream(ref pfRequiresFullStream.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportPadding(this ComPtr thisVtbl, Span pfSupportsPadding) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportPadding(ref pfSupportsPadding.GetPinnableReference()); + } + + /// To be documented. + public static int DoesRequireFixedSize(this ComPtr thisVtbl, Span pfFixedSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesRequireFixedSize(ref pfFixedSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, pcbActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPatterns(ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, ComPtr pIStream, int* pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MatchesPattern(guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(guidContainerFormat, pIStream, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, ComPtr pIStream, ref int pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MatchesPattern(guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, Span pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(guidContainerFormat, ref pIStream.GetPinnableReference(), pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Guid* guidContainerFormat, Span pIStream, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(guidContainerFormat, ref pIStream.GetPinnableReference(), ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Span guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(ref guidContainerFormat.GetPinnableReference(), pIStream, pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, ref Guid guidContainerFormat, ComPtr pIStream, int* pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MatchesPattern(ref guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Span guidContainerFormat, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(ref guidContainerFormat.GetPinnableReference(), pIStream, ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int MatchesPattern(this ComPtr thisVtbl, ref Guid guidContainerFormat, ComPtr pIStream, ref int pfMatches) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->MatchesPattern(ref guidContainerFormat, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pfMatches); + } + + /// To be documented. + public static unsafe int MatchesPattern(this ComPtr thisVtbl, Span guidContainerFormat, Span pIStream, int* pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(ref guidContainerFormat.GetPinnableReference(), ref pIStream.GetPinnableReference(), pfMatches); + } + + /// To be documented. + public static int MatchesPattern(this ComPtr thisVtbl, Span guidContainerFormat, Span pIStream, Span pfMatches) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->MatchesPattern(ref guidContainerFormat.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pfMatches.GetPinnableReference()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref ComPtr ppIReader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((IWICMetadataReader**) ppIReader.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs new file mode 100644 index 0000000000..b1051edfab --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderVtblExtensions.gen.cs @@ -0,0 +1,565 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataReaderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataFormat(this ComPtr thisVtbl, Guid* pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, ref Guid pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataHandlerInfo(this ComPtr thisVtbl, IWICMetadataHandlerInfo** ppIHandler) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandler); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataHandlerInfo(this ComPtr thisVtbl, ref IWICMetadataHandlerInfo* ppIHandler) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataHandlerInfo** ppIHandlerPtr = &ppIHandler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandlerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCount(this ComPtr thisVtbl, uint* pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCount); + return ret; + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, ref uint pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, IWICEnumMetadataItem** ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, ref IWICEnumMetadataItem* ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICEnumMetadataItem** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, Span pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataFormat(ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataHandlerInfo(this ComPtr thisVtbl, ref ComPtr ppIHandler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataHandlerInfo((IWICMetadataHandlerInfo**) ppIHandler.GetAddressOf()); + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, Span pcCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCount(ref pcCount.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, pvarSchema, pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, pvarSchema, ref pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, pvarSchema, ref pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), pvarId, pvarValue); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), ref pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), ref pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(pvarSchema, pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(pvarSchema, in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(pvarSchema, in pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), pvarId, pvarValue); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int GetEnumerator(this ComPtr thisVtbl, ref ComPtr ppIEnumMetadata) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetEnumerator((IWICEnumMetadataItem**) ppIEnumMetadata.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..a294e2b194 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs @@ -0,0 +1,1248 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataWriterInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataFormat(this ComPtr thisVtbl, Guid* pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, ref Guid pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormats, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, ref Guid pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, ref Guid pguidContainerFormats, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidContainerFormatsPtr = &pguidContainerFormats) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, cContainerFormats, pguidContainerFormatsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturer, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, ref char wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceManufacturerPtr = &wzDeviceManufacturer) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceManufacturerPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceManufacturer, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, cchDeviceManufacturer, wzDeviceManufacturerPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceManufacturerPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModels, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, ref char wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzDeviceModelsPtr = &wzDeviceModels) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActual); + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzDeviceModelsPtr = (byte*) SilkMarshal.StringToPtr(wzDeviceModels, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, cchDeviceModels, wzDeviceModelsPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzDeviceModelsPtr); + return ret; + } + + /// To be documented. + public static unsafe int DoesRequireFullStream(this ComPtr thisVtbl, int* pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStream); + return ret; + } + + /// To be documented. + public static int DoesRequireFullStream(this ComPtr thisVtbl, ref int pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfRequiresFullStreamPtr = &pfRequiresFullStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, pfRequiresFullStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportPadding(this ComPtr thisVtbl, int* pfSupportsPadding) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPadding); + return ret; + } + + /// To be documented. + public static int DoesSupportPadding(this ComPtr thisVtbl, ref int pfSupportsPadding) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportsPaddingPtr = &pfSupportsPadding) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsPaddingPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesRequireFixedSize(this ComPtr thisVtbl, int* pfFixedSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSize); + return ret; + } + + /// To be documented. + public static int DoesRequireFixedSize(this ComPtr thisVtbl, ref int pfFixedSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfFixedSizePtr = &pfFixedSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pfFixedSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActual); + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActual); + } + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActual); + } + } + return ret; + } + + /// To be documented. + public static int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) + { + fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActualPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, IWICMetadataWriter** ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, ppIWriter); + return ret; + } + + /// To be documented. + public static unsafe int CreateInstance(this ComPtr thisVtbl, ref IWICMetadataWriter* ppIWriter) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataWriter** ppIWriterPtr = &ppIWriter) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, ppIWriterPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, Span pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataFormat(ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Guid* pguidContainerFormats, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, pguidContainerFormats, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Span pguidContainerFormats, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, ref pguidContainerFormats.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetContainerFormats(this ComPtr thisVtbl, uint cContainerFormats, Span pguidContainerFormats, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetContainerFormats(cContainerFormats, ref pguidContainerFormats.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, char* wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, Span wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, ref wzDeviceManufacturer.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceManufacturer(this ComPtr thisVtbl, uint cchDeviceManufacturer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceManufacturer, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceManufacturer(cchDeviceManufacturer, wzDeviceManufacturer, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, char* wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, Span wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, ref wzDeviceModels.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetDeviceModels(this ComPtr thisVtbl, uint cchDeviceModels, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzDeviceModels, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetDeviceModels(cchDeviceModels, wzDeviceModels, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int DoesRequireFullStream(this ComPtr thisVtbl, Span pfRequiresFullStream) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesRequireFullStream(ref pfRequiresFullStream.GetPinnableReference()); + } + + /// To be documented. + public static int DoesSupportPadding(this ComPtr thisVtbl, Span pfSupportsPadding) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportPadding(ref pfSupportsPadding.GetPinnableReference()); + } + + /// To be documented. + public static int DoesRequireFixedSize(this ComPtr thisVtbl, Span pfFixedSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesRequireFixedSize(ref pfFixedSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(guidContainerFormat, cbSize, pHeader, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, pcbActual); + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetHeader(ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static int CreateInstance(this ComPtr thisVtbl, ref ComPtr ppIWriter) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CreateInstance((IWICMetadataWriter**) ppIWriter.GetAddressOf()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs new file mode 100644 index 0000000000..d0532b963e --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterVtblExtensions.gen.cs @@ -0,0 +1,974 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICMetadataWriterVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataFormat(this ComPtr thisVtbl, Guid* pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormat); + return ret; + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, ref Guid pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidMetadataFormatPtr = &pguidMetadataFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pguidMetadataFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataHandlerInfo(this ComPtr thisVtbl, IWICMetadataHandlerInfo** ppIHandler) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandler); + return ret; + } + + /// To be documented. + public static unsafe int GetMetadataHandlerInfo(this ComPtr thisVtbl, ref IWICMetadataHandlerInfo* ppIHandler) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICMetadataHandlerInfo** ppIHandlerPtr = &ppIHandler) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppIHandlerPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCount(this ComPtr thisVtbl, uint* pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCount); + return ret; + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, ref uint pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, ref T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, ref T0 pvarSchema, ref T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, ref T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, ref T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, IWICEnumMetadataItem** ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadata); + return ret; + } + + /// To be documented. + public static unsafe int GetEnumerator(this ComPtr thisVtbl, ref IWICEnumMetadataItem* ppIEnumMetadata) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICEnumMetadataItem** ppIEnumMetadataPtr = &ppIEnumMetadata) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppIEnumMetadataPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public static int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValue); + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarId, pvarValuePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchema, pvarIdPtr, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValue); + } + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarId, pvarValuePtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValue); + } + } + return ret; + } + + /// To be documented. + public static int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T2 pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + fixed (void* pvarValuePtr = &pvarValue) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, nIndex, pvarSchemaPtr, pvarIdPtr, pvarValuePtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarId); + return ret; + } + + /// To be documented. + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarId) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchema, pvarIdPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarId); + } + return ret; + } + + /// To be documented. + public static int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T1 pvarId) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvarSchemaPtr = &pvarSchema) + { + fixed (void* pvarIdPtr = &pvarId) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pvarSchemaPtr, pvarIdPtr); + } + } + return ret; + } + + /// To be documented. + public static int RemoveValueByIndex(this ComPtr thisVtbl, uint nIndex) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, nIndex); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetMetadataFormat(this ComPtr thisVtbl, Span pguidMetadataFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetMetadataFormat(ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetMetadataHandlerInfo(this ComPtr thisVtbl, ref ComPtr ppIHandler) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetMetadataHandlerInfo((IWICMetadataHandlerInfo**) ppIHandler.GetAddressOf()); + } + + /// To be documented. + public static int GetCount(this ComPtr thisVtbl, Span pcCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCount(ref pcCount.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, pvarSchema, pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, pvarSchema, ref pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, void* pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, pvarSchema, ref pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), pvarId, pvarValue); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), ref pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int GetValueByIndex(this ComPtr thisVtbl, uint nIndex, Span pvarSchema, Span pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValueByIndex(nIndex, ref pvarSchema.GetPinnableReference(), ref pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(pvarSchema, pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(pvarSchema, in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(pvarSchema, in pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), pvarId, pvarValue); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), pvarId, ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int GetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, Span pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), ref pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static int GetEnumerator(this ComPtr thisVtbl, ref ComPtr ppIEnumMetadata) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetEnumerator((IWICEnumMetadataItem**) ppIEnumMetadata.GetAddressOf()); + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(pvarSchema, pvarId, in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(pvarSchema, in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(pvarSchema, in pvarId.GetPinnableReference(), in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(in pvarSchema.GetPinnableReference(), pvarId, pvarValue); + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(in pvarSchema.GetPinnableReference(), pvarId, in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int SetValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, pvarSchema, pvarId, in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, pvarSchema, in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, pvarSchema, in pvarId.GetPinnableReference(), in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, in pvarSchema.GetPinnableReference(), pvarId, pvarValue); + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, in pvarSchema.GetPinnableReference(), pvarId, in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarValue) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), pvarValue); + } + + /// To be documented. + public static int SetValueByIndex(this ComPtr thisVtbl, uint nIndex, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarValue) where T0 : unmanaged where T1 : unmanaged where T2 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SetValueByIndex(nIndex, in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference(), in pvarValue.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RemoveValue(pvarSchema, in pvarId.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pvarId) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RemoveValue(in pvarSchema.GetPinnableReference(), pvarId); + } + + /// To be documented. + public static int RemoveValue(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarSchema, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pvarId) where T0 : unmanaged where T1 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->RemoveValue(in pvarSchema.GetPinnableReference(), in pvarId.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs new file mode 100644 index 0000000000..2bd668e147 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs @@ -0,0 +1,450 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPaletteVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int InitializePredefined(this ComPtr thisVtbl, WICBitmapPaletteType ePaletteType, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ePaletteType, fAddTransparentColor); + return ret; + } + + /// To be documented. + public static unsafe int InitializeCustom(this ComPtr thisVtbl, uint* pColors, uint cCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pColors, cCount); + return ret; + } + + /// To be documented. + public static int InitializeCustom(this ComPtr thisVtbl, ref uint pColors, uint cCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pColorsPtr = &pColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pColorsPtr, cCount); + } + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromBitmap(this ComPtr thisVtbl, IWICBitmapSource* pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pISurface, cCount, fAddTransparentColor); + return ret; + } + + /// To be documented. + public static int InitializeFromBitmap(this ComPtr thisVtbl, ref IWICBitmapSource pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource* pISurfacePtr = &pISurface) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pISurfacePtr, cCount, fAddTransparentColor); + } + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int InitializeFromPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetType(this ComPtr thisVtbl, WICBitmapPaletteType* pePaletteType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteType); + return ret; + } + + /// To be documented. + public static int GetType(this ComPtr thisVtbl, ref WICBitmapPaletteType pePaletteType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPaletteType* pePaletteTypePtr = &pePaletteType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorCount(this ComPtr thisVtbl, uint* pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pcCount); + return ret; + } + + /// To be documented. + public static int GetColorCount(this ComPtr thisVtbl, ref uint pcCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcCountPtr = &pcCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pcCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColors(this ComPtr thisVtbl, uint cCount, uint* pColors, uint* pcActualColors) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColors, pcActualColors); + return ret; + } + + /// To be documented. + public static unsafe int GetColors(this ComPtr thisVtbl, uint cCount, uint* pColors, ref uint pcActualColors) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcActualColorsPtr = &pcActualColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColors, pcActualColorsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColors(this ComPtr thisVtbl, uint cCount, ref uint pColors, uint* pcActualColors) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pColorsPtr = &pColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColorsPtr, pcActualColors); + } + return ret; + } + + /// To be documented. + public static int GetColors(this ComPtr thisVtbl, uint cCount, ref uint pColors, ref uint pcActualColors) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pColorsPtr = &pColors) + { + fixed (uint* pcActualColorsPtr = &pcActualColors) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cCount, pColorsPtr, pcActualColorsPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int IsBlackWhite(this ComPtr thisVtbl, int* pfIsBlackWhite) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, pfIsBlackWhite); + return ret; + } + + /// To be documented. + public static int IsBlackWhite(this ComPtr thisVtbl, ref int pfIsBlackWhite) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfIsBlackWhitePtr = &pfIsBlackWhite) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, pfIsBlackWhitePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int IsGrayscale(this ComPtr thisVtbl, int* pfIsGrayscale) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pfIsGrayscale); + return ret; + } + + /// To be documented. + public static int IsGrayscale(this ComPtr thisVtbl, ref int pfIsGrayscale) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfIsGrayscalePtr = &pfIsGrayscale) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pfIsGrayscalePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int HasAlpha(this ComPtr thisVtbl, int* pfHasAlpha) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pfHasAlpha); + return ret; + } + + /// To be documented. + public static int HasAlpha(this ComPtr thisVtbl, ref int pfHasAlpha) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfHasAlphaPtr = &pfHasAlpha) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pfHasAlphaPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int InitializeCustom(this ComPtr thisVtbl, Span pColors, uint cCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeCustom(ref pColors.GetPinnableReference(), cCount); + } + + /// To be documented. + public static int InitializeFromBitmap(this ComPtr thisVtbl, ComPtr pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->InitializeFromBitmap((IWICBitmapSource*) pISurface.Handle, cCount, fAddTransparentColor); + } + + /// To be documented. + public static int InitializeFromBitmap(this ComPtr thisVtbl, Span pISurface, uint cCount, Silk.NET.Core.Bool32 fAddTransparentColor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromBitmap(ref pISurface.GetPinnableReference(), cCount, fAddTransparentColor); + } + + /// To be documented. + public static int InitializeFromPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->InitializeFromPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int InitializeFromPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static int GetType(this ComPtr thisVtbl, Span pePaletteType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetType(ref pePaletteType.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorCount(this ComPtr thisVtbl, Span pcCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColorCount(ref pcCount.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColors(this ComPtr thisVtbl, uint cCount, uint* pColors, Span pcActualColors) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColors(cCount, pColors, ref pcActualColors.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetColors(this ComPtr thisVtbl, uint cCount, Span pColors, uint* pcActualColors) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColors(cCount, ref pColors.GetPinnableReference(), pcActualColors); + } + + /// To be documented. + public static int GetColors(this ComPtr thisVtbl, uint cCount, Span pColors, Span pcActualColors) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetColors(cCount, ref pColors.GetPinnableReference(), ref pcActualColors.GetPinnableReference()); + } + + /// To be documented. + public static int IsBlackWhite(this ComPtr thisVtbl, Span pfIsBlackWhite) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsBlackWhite(ref pfIsBlackWhite.GetPinnableReference()); + } + + /// To be documented. + public static int IsGrayscale(this ComPtr thisVtbl, Span pfIsGrayscale) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->IsGrayscale(ref pfIsGrayscale.GetPinnableReference()); + } + + /// To be documented. + public static int HasAlpha(this ComPtr thisVtbl, Span pfHasAlpha) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->HasAlpha(ref pfHasAlpha.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPersistStreamVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPersistStreamVtblExtensions.gen.cs new file mode 100644 index 0000000000..3214d9d2e0 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPersistStreamVtblExtensions.gen.cs @@ -0,0 +1,387 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPersistStreamVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetClassID(this ComPtr thisVtbl, Guid* pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pClassID); + return ret; + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, ref Guid pClassID) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pClassIDPtr = &pClassID) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pClassIDPtr); + } + return ret; + } + + /// To be documented. + public static int IsDirty(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Load(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStm); + return ret; + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Save(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pStm, fClearDirty); + return ret; + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pStmPtr = &pStm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pStmPtr, fClearDirty); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSizeMax(this ComPtr thisVtbl, ulong* pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pcbSize); + return ret; + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, ref ulong pcbSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pcbSizePtr = &pcbSize) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pcbSizePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int LoadEx(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStream, pguidPreferredVendor, dwPersistOptions); + return ret; + } + + /// To be documented. + public static unsafe int LoadEx(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPreferredVendorPtr = &pguidPreferredVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStream, pguidPreferredVendorPtr, dwPersistOptions); + } + return ret; + } + + /// To be documented. + public static unsafe int LoadEx(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStreamPtr, pguidPreferredVendor, dwPersistOptions); + } + return ret; + } + + /// To be documented. + public static int LoadEx(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + fixed (Guid* pguidPreferredVendorPtr = &pguidPreferredVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pIStreamPtr, pguidPreferredVendorPtr, dwPersistOptions); + } + } + return ret; + } + + /// To be documented. + public static unsafe int SaveEx(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIStream, dwPersistOptions, fClearDirty); + return ret; + } + + /// To be documented. + public static int SaveEx(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pIStreamPtr, dwPersistOptions, fClearDirty); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetClassID(this ComPtr thisVtbl, Span pClassID) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetClassID(ref pClassID.GetPinnableReference()); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, ComPtr pStm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Load((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle); + } + + /// To be documented. + public static int Load(this ComPtr thisVtbl, Span pStm) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Load(ref pStm.GetPinnableReference()); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, ComPtr pStm, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Save((Silk.NET.Core.Win32Extras.IStream*) pStm.Handle, fClearDirty); + } + + /// To be documented. + public static int Save(this ComPtr thisVtbl, Span pStm, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Save(ref pStm.GetPinnableReference(), fClearDirty); + } + + /// To be documented. + public static int GetSizeMax(this ComPtr thisVtbl, Span pcbSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSizeMax(ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int LoadEx(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadEx((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidPreferredVendor, dwPersistOptions); + } + + /// To be documented. + public static unsafe int LoadEx(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadEx(pIStream, in pguidPreferredVendor.GetPinnableReference(), dwPersistOptions); + } + + /// To be documented. + public static int LoadEx(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidPreferredVendor, uint dwPersistOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->LoadEx((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, in pguidPreferredVendor, dwPersistOptions); + } + + /// To be documented. + public static unsafe int LoadEx(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadEx(ref pIStream.GetPinnableReference(), pguidPreferredVendor, dwPersistOptions); + } + + /// To be documented. + public static int LoadEx(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidPreferredVendor, uint dwPersistOptions) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->LoadEx(ref pIStream.GetPinnableReference(), in pguidPreferredVendor.GetPinnableReference(), dwPersistOptions); + } + + /// To be documented. + public static int SaveEx(this ComPtr thisVtbl, ComPtr pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->SaveEx((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, dwPersistOptions, fClearDirty); + } + + /// To be documented. + public static int SaveEx(this ComPtr thisVtbl, Span pIStream, uint dwPersistOptions, Silk.NET.Core.Bool32 fClearDirty) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SaveEx(ref pIStream.GetPinnableReference(), dwPersistOptions, fClearDirty); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs new file mode 100644 index 0000000000..2294732f66 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs @@ -0,0 +1,936 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPixelFormatInfo2VtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFormatGUID(this ComPtr thisVtbl, Guid* pFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormat); + return ret; + } + + /// To be documented. + public static int GetFormatGUID(this ComPtr thisVtbl, ref Guid pFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pFormatPtr = &pFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContext(this ComPtr thisVtbl, IWICColorContext** ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContext); + return ret; + } + + /// To be documented. + public static unsafe int GetColorContext(this ComPtr thisVtbl, ref IWICColorContext* ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetBitsPerPixel(this ComPtr thisVtbl, uint* puiBitsPerPixel) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixel); + return ret; + } + + /// To be documented. + public static int GetBitsPerPixel(this ComPtr thisVtbl, ref uint puiBitsPerPixel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiBitsPerPixelPtr = &puiBitsPerPixel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixelPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelCount(this ComPtr thisVtbl, uint* puiChannelCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCount); + return ret; + } + + /// To be documented. + public static int GetChannelCount(this ComPtr thisVtbl, ref uint puiChannelCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiChannelCountPtr = &puiChannelCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual); + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int SupportsTransparency(this ComPtr thisVtbl, int* pfSupportsTransparency) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsTransparency); + return ret; + } + + /// To be documented. + public static int SupportsTransparency(this ComPtr thisVtbl, ref int pfSupportsTransparency) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfSupportsTransparencyPtr = &pfSupportsTransparency) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pfSupportsTransparencyPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetNumericRepresentation(this ComPtr thisVtbl, WICPixelFormatNumericRepresentation* pNumericRepresentation) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentation); + return ret; + } + + /// To be documented. + public static int GetNumericRepresentation(this ComPtr thisVtbl, ref WICPixelFormatNumericRepresentation pNumericRepresentation) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICPixelFormatNumericRepresentation* pNumericRepresentationPtr = &pNumericRepresentation) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentationPtr); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFormatGUID(this ComPtr thisVtbl, Span pFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFormatGUID(ref pFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorContext(this ComPtr thisVtbl, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContext((IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public static int GetBitsPerPixel(this ComPtr thisVtbl, Span puiBitsPerPixel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetBitsPerPixel(ref puiBitsPerPixel.GetPinnableReference()); + } + + /// To be documented. + public static int GetChannelCount(this ComPtr thisVtbl, Span puiChannelCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelCount(ref puiChannelCount.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, pbMaskBuffer, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, Span pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, ref pbMaskBuffer.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, Span pbMaskBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, ref pbMaskBuffer.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, pbMaskBuffer, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static int SupportsTransparency(this ComPtr thisVtbl, Span pfSupportsTransparency) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->SupportsTransparency(ref pfSupportsTransparency.GetPinnableReference()); + } + + /// To be documented. + public static int GetNumericRepresentation(this ComPtr thisVtbl, Span pNumericRepresentation) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetNumericRepresentation(ref pNumericRepresentation.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs new file mode 100644 index 0000000000..8b7e0e7550 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs @@ -0,0 +1,878 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPixelFormatInfoVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + return ret; + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICComponentType* pTypePtr = &pType) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCLSID(this ComPtr thisVtbl, Guid* pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsid); + return ret; + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, ref Guid pclsid) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pclsidPtr = &pclsid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pclsidPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSigningStatus(this ComPtr thisVtbl, uint* pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatus); + return ret; + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, ref uint pStatus) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pStatusPtr = &pStatus) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pStatusPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthor, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, ref char wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzAuthorPtr = &wzAuthor) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActual); + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzAuthorPtr = (byte*) SilkMarshal.StringToPtr(wzAuthor, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, cchAuthor, wzAuthorPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzAuthorPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetVendorGUID(this ComPtr thisVtbl, Guid* pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendor); + return ret; + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, ref Guid pguidVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidVendorPtr = &pguidVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pguidVendorPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, ref char wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzVersionPtr = &wzVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzVersionPtr = (byte*) SilkMarshal.StringToPtr(wzVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, cchVersion, wzVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersion, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, ref char wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzSpecVersionPtr = &wzSpecVersion) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActual); + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzSpecVersionPtr = (byte*) SilkMarshal.StringToPtr(wzSpecVersion, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, cchSpecVersion, wzSpecVersionPtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzSpecVersionPtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActual); + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyName, pcchActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + } + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, ref char wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFriendlyNamePtr = &wzFriendlyName) + { + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActual); + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, ref uint pcchActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFriendlyNamePtr = (byte*) SilkMarshal.StringToPtr(wzFriendlyName, NativeStringEncoding.UTF8); + fixed (uint* pcchActualPtr = &pcchActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, cchFriendlyName, wzFriendlyNamePtr, pcchActualPtr); + } + SilkMarshal.Free((nint)wzFriendlyNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int GetFormatGUID(this ComPtr thisVtbl, Guid* pFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormat); + return ret; + } + + /// To be documented. + public static int GetFormatGUID(this ComPtr thisVtbl, ref Guid pFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pFormatPtr = &pFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetColorContext(this ComPtr thisVtbl, IWICColorContext** ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContext); + return ret; + } + + /// To be documented. + public static unsafe int GetColorContext(this ComPtr thisVtbl, ref IWICColorContext* ppIColorContext) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICColorContext** ppIColorContextPtr = &ppIColorContext) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ppIColorContextPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetBitsPerPixel(this ComPtr thisVtbl, uint* puiBitsPerPixel) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixel); + return ret; + } + + /// To be documented. + public static int GetBitsPerPixel(this ComPtr thisVtbl, ref uint puiBitsPerPixel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiBitsPerPixelPtr = &puiBitsPerPixel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, puiBitsPerPixelPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelCount(this ComPtr thisVtbl, uint* puiChannelCount) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCount); + return ret; + } + + /// To be documented. + public static int GetChannelCount(this ComPtr thisVtbl, ref uint puiChannelCount) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiChannelCountPtr = &puiChannelCount) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, puiChannelCountPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActual); + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBuffer, pcbActualPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + } + return ret; + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, ref byte pbMaskBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbMaskBufferPtr = &pbMaskBuffer) + { + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActual); + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, ref uint pcbActual) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbMaskBufferPtr = (byte*) SilkMarshal.StringToPtr(pbMaskBuffer, NativeStringEncoding.UTF8); + fixed (uint* pcbActualPtr = &pcbActual) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, uiChannelIndex, cbMaskBuffer, pbMaskBufferPtr, pcbActualPtr); + } + SilkMarshal.Free((nint)pbMaskBufferPtr); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetComponentType(this ComPtr thisVtbl, Span pType) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetComponentType(ref pType.GetPinnableReference()); + } + + /// To be documented. + public static int GetCLSID(this ComPtr thisVtbl, Span pclsid) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCLSID(ref pclsid.GetPinnableReference()); + } + + /// To be documented. + public static int GetSigningStatus(this ComPtr thisVtbl, Span pStatus) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSigningStatus(ref pStatus.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, char* wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, Span wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, ref wzAuthor.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetAuthor(this ComPtr thisVtbl, uint cchAuthor, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzAuthor, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetAuthor(cchAuthor, wzAuthor, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVendorGUID(this ComPtr thisVtbl, Span pguidVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVendorGUID(ref pguidVendor.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, char* wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, Span wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, ref wzVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetVersion(this ComPtr thisVtbl, uint cchVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetVersion(cchVersion, wzVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, char* wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, Span wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, ref wzSpecVersion.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetSpecVersion(this ComPtr thisVtbl, uint cchSpecVersion, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzSpecVersion, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSpecVersion(cchSpecVersion, wzSpecVersion, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, char* wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, uint* pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, Span wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, ref wzFriendlyName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFriendlyName(this ComPtr thisVtbl, uint cchFriendlyName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzFriendlyName, Span pcchActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFriendlyName(cchFriendlyName, wzFriendlyName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetFormatGUID(this ComPtr thisVtbl, Span pFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetFormatGUID(ref pFormat.GetPinnableReference()); + } + + /// To be documented. + public static int GetColorContext(this ComPtr thisVtbl, ref ComPtr ppIColorContext) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetColorContext((IWICColorContext**) ppIColorContext.GetAddressOf()); + } + + /// To be documented. + public static int GetBitsPerPixel(this ComPtr thisVtbl, Span puiBitsPerPixel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetBitsPerPixel(ref puiBitsPerPixel.GetPinnableReference()); + } + + /// To be documented. + public static int GetChannelCount(this ComPtr thisVtbl, Span puiChannelCount) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelCount(ref puiChannelCount.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, byte* pbMaskBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, pbMaskBuffer, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, Span pbMaskBuffer, uint* pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, ref pbMaskBuffer.GetPinnableReference(), pcbActual); + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, Span pbMaskBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, ref pbMaskBuffer.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static int GetChannelMask(this ComPtr thisVtbl, uint uiChannelIndex, uint cbMaskBuffer, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbMaskBuffer, Span pcbActual) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetChannelMask(uiChannelIndex, cbMaskBuffer, pbMaskBuffer, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs new file mode 100644 index 0000000000..4745cadcf8 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs @@ -0,0 +1,230 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPlanarBitmapFrameEncodeVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int WritePixels(this ComPtr thisVtbl, uint lineCount, WICBitmapPlane* pPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanes, cPlanes); + return ret; + } + + /// To be documented. + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, ref WICBitmapPlane pPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPlane* pPlanesPtr = &pPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanesPtr, cPlanes); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, WICRect* prcSource) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref WICRect prcSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcSourcePtr = &prcSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, WICRect* prcSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); + } + return ret; + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref WICRect prcSource) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (WICRect* prcSourcePtr = &prcSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, Span pPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WritePixels(lineCount, ref pPlanes.GetPinnableReference(), cPlanes); + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, WICRect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, prcSource); + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span prcSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteSource(ppPlanes, cPlanes, ref prcSource.GetPinnableReference()); + } + + /// To be documented. + public static int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref WICRect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->WriteSource((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, ref prcSource); + } + + /// To be documented. + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span prcSource) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->WriteSource(ref ppPlanes, cPlanes, ref prcSource.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs new file mode 100644 index 0000000000..aedf279566 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs @@ -0,0 +1,969 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPlanarBitmapSourceTransformVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + } + } + } + } + return ret; + } + + /// To be documented. + public static int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) + { + fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + { + fixed (int* pfIsSupportedPtr = &pfIsSupported) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + } + } + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcSourcePtr = &prcSource) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcSourcePtr = &prcSource) + { + fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(puiWidth, ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), puiHeight, dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, pguidDstFormats, ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, pfIsSupported); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), pPlaneDescriptions, cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, pfIsSupported); + } + + /// To be documented. + public static int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->DoesSupportTransform(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference(), dstTransform, dstPlanarOptions, in pguidDstFormats.GetPinnableReference(), ref pPlaneDescriptions.GetPinnableReference(), cPlanes, ref pfIsSupported.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, in pDstPlanes.GetPinnableReference(), cPlanes); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prcSource.GetPinnableReference(), uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prcSource.GetPinnableReference(), uiWidth, uiHeight, dstTransform, dstPlanarOptions, in pDstPlanes.GetPinnableReference(), cPlanes); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs new file mode 100644 index 0000000000..7d17b62324 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs @@ -0,0 +1,804 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICPlanarFormatConverterVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight); + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight); + } + return ret; + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* puiWidthPtr = &puiWidth) + { + fixed (uint* puiHeightPtr = &puiHeight) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int GetPixelFormat(this ComPtr thisVtbl, Guid* pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormat); + return ret; + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, ref Guid pPixelFormat) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pPixelFormatPtr = &pPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pPixelFormatPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiY); + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiX, pDpiYPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, ref double pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiY); + } + return ret; + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, ref double pDpiX, ref double pDpiY) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (double* pDpiXPtr = &pDpiX) + { + fixed (double* pDpiYPtr = &pDpiY) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pDpiXPtr, pDpiYPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPalette(this ComPtr thisVtbl, IWICPalette* pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalette); + return ret; + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette pIPalette) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pIPalettePtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + } + } + return ret; + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (WICRect* prcPtr = &prc) + { + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + SilkMarshal.Free((nint)pbBufferPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) + { + fixed (Guid* dstFormatPtr = &dstFormat) + { + fixed (IWICPalette* pIPalettePtr = &pIPalette) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + } + } + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormat, pfCanConvert); + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormat, pfCanConvertPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormatPtr, pfCanConvert); + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormats, cSrcPlanes, dstPixelFormatPtr, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormat, pfCanConvert); + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormat, pfCanConvertPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormatPtr, pfCanConvert); + } + } + return ret; + } + + /// To be documented. + public static int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pSrcPixelFormats, uint cSrcPlanes, ref Guid dstPixelFormat, ref int pfCanConvert) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pSrcPixelFormatsPtr = &pSrcPixelFormats) + { + fixed (Guid* dstPixelFormatPtr = &dstPixelFormat) + { + fixed (int* pfCanConvertPtr = &pfCanConvert) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pSrcPixelFormatsPtr, cSrcPlanes, dstPixelFormatPtr, pfCanConvertPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(puiWidth, ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetSize(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), puiHeight); + } + + /// To be documented. + public static int GetSize(this ComPtr thisVtbl, Span puiWidth, Span puiHeight) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetSize(ref puiWidth.GetPinnableReference(), ref puiHeight.GetPinnableReference()); + } + + /// To be documented. + public static int GetPixelFormat(this ComPtr thisVtbl, Span pPixelFormat) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPixelFormat(ref pPixelFormat.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, double* pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(pDpiX, ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int GetResolution(this ComPtr thisVtbl, Span pDpiX, double* pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), pDpiY); + } + + /// To be documented. + public static int GetResolution(this ComPtr thisVtbl, Span pDpiX, Span pDpiY) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetResolution(ref pDpiX.GetPinnableReference(), ref pDpiY.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, ComPtr pIPalette) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyPalette((IWICPalette*) pIPalette.Handle); + } + + /// To be documented. + public static int CopyPalette(this ComPtr thisVtbl, Span pIPalette) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPalette(ref pIPalette.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(prc, cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, ref pbBuffer.GetPinnableReference()); + } + + /// To be documented. + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyPixels(in prc.GetPinnableReference(), cbStride, cbBufferSize, pbBuffer); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ppPlanes, cPlanes, dstFormat, dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ppPlanes, cPlanes, ref dstFormat.GetPinnableReference(), dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ppPlanes, cPlanes, ref dstFormat.GetPinnableReference(), dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize((IWICBitmapSource**) ppPlanes.GetAddressOf(), cPlanes, ref dstFormat, dither, ref pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref ppPlanes, cPlanes, dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref ppPlanes, cPlanes, dstFormat, dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref ppPlanes, cPlanes, ref dstFormat.GetPinnableReference(), dither, pIPalette, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Initialize(ref ppPlanes, cPlanes, ref dstFormat, dither, (IWICPalette*) pIPalette.Handle, alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Initialize(ref ppPlanes, cPlanes, ref dstFormat.GetPinnableReference(), dither, ref pIPalette.GetPinnableReference(), alphaThresholdPercent, paletteTranslate); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(pSrcPixelFormats, cSrcPlanes, dstPixelFormat, ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Span dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(pSrcPixelFormats, cSrcPlanes, ref dstPixelFormat.GetPinnableReference(), pfCanConvert); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pSrcPixelFormats, uint cSrcPlanes, Span dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(pSrcPixelFormats, cSrcPlanes, ref dstPixelFormat.GetPinnableReference(), ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(in pSrcPixelFormats.GetPinnableReference(), cSrcPlanes, dstPixelFormat, pfCanConvert); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pSrcPixelFormats, uint cSrcPlanes, Guid* dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(in pSrcPixelFormats.GetPinnableReference(), cSrcPlanes, dstPixelFormat, ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pSrcPixelFormats, uint cSrcPlanes, Span dstPixelFormat, int* pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(in pSrcPixelFormats.GetPinnableReference(), cSrcPlanes, ref dstPixelFormat.GetPinnableReference(), pfCanConvert); + } + + /// To be documented. + public static int CanConvert(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pSrcPixelFormats, uint cSrcPlanes, Span dstPixelFormat, Span pfCanConvert) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CanConvert(in pSrcPixelFormats.GetPinnableReference(), cSrcPlanes, ref dstPixelFormat.GetPinnableReference(), ref pfCanConvert.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs new file mode 100644 index 0000000000..8a27d5132d --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs @@ -0,0 +1,130 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICProgressCallbackVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static int Notify(this ComPtr thisVtbl, uint uFrameNum, WICProgressOperation operation, double dblProgress) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, uFrameNum, operation, dblProgress); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressiveLevelControlVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressiveLevelControlVtblExtensions.gen.cs new file mode 100644 index 0000000000..68373a2b02 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressiveLevelControlVtblExtensions.gen.cs @@ -0,0 +1,188 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICProgressiveLevelControlVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetLevelCount(this ComPtr thisVtbl, uint* pcLevels) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pcLevels); + return ret; + } + + /// To be documented. + public static int GetLevelCount(this ComPtr thisVtbl, ref uint pcLevels) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcLevelsPtr = &pcLevels) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pcLevelsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetCurrentLevel(this ComPtr thisVtbl, uint* pnLevel) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pnLevel); + return ret; + } + + /// To be documented. + public static int GetCurrentLevel(this ComPtr thisVtbl, ref uint pnLevel) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pnLevelPtr = &pnLevel) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pnLevelPtr); + } + return ret; + } + + /// To be documented. + public static int SetCurrentLevel(this ComPtr thisVtbl, uint nLevel) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, nLevel); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetLevelCount(this ComPtr thisVtbl, Span pcLevels) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetLevelCount(ref pcLevels.GetPinnableReference()); + } + + /// To be documented. + public static int GetCurrentLevel(this ComPtr thisVtbl, Span pnLevel) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetCurrentLevel(ref pnLevel.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs new file mode 100644 index 0000000000..6e2c45cdda --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs @@ -0,0 +1,226 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawCapabilitiesInfo")] + public unsafe partial struct WICRawCapabilitiesInfo + { + public WICRawCapabilitiesInfo + ( + uint? cbSize = null, + uint? codecMajorVersion = null, + uint? codecMinorVersion = null, + WICRawCapabilities? exposureCompensationSupport = null, + WICRawCapabilities? contrastSupport = null, + WICRawCapabilities? rGBWhitePointSupport = null, + WICRawCapabilities? namedWhitePointSupport = null, + uint? namedWhitePointSupportMask = null, + WICRawCapabilities? kelvinWhitePointSupport = null, + WICRawCapabilities? gammaSupport = null, + WICRawCapabilities? tintSupport = null, + WICRawCapabilities? saturationSupport = null, + WICRawCapabilities? sharpnessSupport = null, + WICRawCapabilities? noiseReductionSupport = null, + WICRawCapabilities? destinationColorProfileSupport = null, + WICRawCapabilities? toneCurveSupport = null, + WICRawRotationCapabilities? rotationSupport = null, + WICRawCapabilities? renderModeSupport = null + ) : this() + { + if (cbSize is not null) + { + CbSize = cbSize.Value; + } + + if (codecMajorVersion is not null) + { + CodecMajorVersion = codecMajorVersion.Value; + } + + if (codecMinorVersion is not null) + { + CodecMinorVersion = codecMinorVersion.Value; + } + + if (exposureCompensationSupport is not null) + { + ExposureCompensationSupport = exposureCompensationSupport.Value; + } + + if (contrastSupport is not null) + { + ContrastSupport = contrastSupport.Value; + } + + if (rGBWhitePointSupport is not null) + { + RGBWhitePointSupport = rGBWhitePointSupport.Value; + } + + if (namedWhitePointSupport is not null) + { + NamedWhitePointSupport = namedWhitePointSupport.Value; + } + + if (namedWhitePointSupportMask is not null) + { + NamedWhitePointSupportMask = namedWhitePointSupportMask.Value; + } + + if (kelvinWhitePointSupport is not null) + { + KelvinWhitePointSupport = kelvinWhitePointSupport.Value; + } + + if (gammaSupport is not null) + { + GammaSupport = gammaSupport.Value; + } + + if (tintSupport is not null) + { + TintSupport = tintSupport.Value; + } + + if (saturationSupport is not null) + { + SaturationSupport = saturationSupport.Value; + } + + if (sharpnessSupport is not null) + { + SharpnessSupport = sharpnessSupport.Value; + } + + if (noiseReductionSupport is not null) + { + NoiseReductionSupport = noiseReductionSupport.Value; + } + + if (destinationColorProfileSupport is not null) + { + DestinationColorProfileSupport = destinationColorProfileSupport.Value; + } + + if (toneCurveSupport is not null) + { + ToneCurveSupport = toneCurveSupport.Value; + } + + if (rotationSupport is not null) + { + RotationSupport = rotationSupport.Value; + } + + if (renderModeSupport is not null) + { + RenderModeSupport = renderModeSupport.Value; + } + } + + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "cbSize")] + public uint CbSize; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "CodecMajorVersion")] + public uint CodecMajorVersion; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "CodecMinorVersion")] + public uint CodecMinorVersion; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "ExposureCompensationSupport")] + public WICRawCapabilities ExposureCompensationSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "ContrastSupport")] + public WICRawCapabilities ContrastSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "RGBWhitePointSupport")] + public WICRawCapabilities RGBWhitePointSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "NamedWhitePointSupport")] + public WICRawCapabilities NamedWhitePointSupport; + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "NamedWhitePointSupportMask")] + public uint NamedWhitePointSupportMask; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "KelvinWhitePointSupport")] + public WICRawCapabilities KelvinWhitePointSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "GammaSupport")] + public WICRawCapabilities GammaSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "TintSupport")] + public WICRawCapabilities TintSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "SaturationSupport")] + public WICRawCapabilities SaturationSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "SharpnessSupport")] + public WICRawCapabilities SharpnessSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "NoiseReductionSupport")] + public WICRawCapabilities NoiseReductionSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "DestinationColorProfileSupport")] + public WICRawCapabilities DestinationColorProfileSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "ToneCurveSupport")] + public WICRawCapabilities ToneCurveSupport; + + [NativeName("Type", "WICRawRotationCapabilities")] + [NativeName("Type.Name", "WICRawRotationCapabilities")] + [NativeName("Name", "RotationSupport")] + public WICRawRotationCapabilities RotationSupport; + + [NativeName("Type", "WICRawCapabilities")] + [NativeName("Type.Name", "WICRawCapabilities")] + [NativeName("Name", "RenderModeSupport")] + public WICRawCapabilities RenderModeSupport; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs new file mode 100644 index 0000000000..3515364964 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs @@ -0,0 +1,70 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawToneCurve")] + public unsafe partial struct WICRawToneCurve + { + public WICRawToneCurve + ( + uint? cPoints = null + ) : this() + { + if (cPoints is not null) + { + CPoints = cPoints.Value; + } + } + + + [NativeName("Type", "UINT")] + [NativeName("Type.Name", "UINT")] + [NativeName("Name", "cPoints")] + public uint CPoints; + + [NativeName("Type", "WICRawToneCurvePoint[1]")] + [NativeName("Type.Name", "WICRawToneCurvePoint[1]")] + [NativeName("Name", "aPoints")] + public APointsBuffer APoints; + + public struct APointsBuffer + { + public WICRawToneCurvePoint Element0; + public ref WICRawToneCurvePoint this[int index] + { + get + { + if (index > 0 || index < 0) + { + throw new ArgumentOutOfRangeException(nameof(index)); + } + + fixed (WICRawToneCurvePoint* ptr = &Element0) + { + return ref ptr[index]; + } + } + } + +#if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER + public Span AsSpan() + => MemoryMarshal.CreateSpan(ref Element0, 1); +#endif + } + + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs new file mode 100644 index 0000000000..e075265034 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs @@ -0,0 +1,50 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRawToneCurvePoint")] + public unsafe partial struct WICRawToneCurvePoint + { + public WICRawToneCurvePoint + ( + double? input = null, + double? output = null + ) : this() + { + if (input is not null) + { + Input = input.Value; + } + + if (output is not null) + { + Output = output.Value; + } + } + + + [NativeName("Type", "double")] + [NativeName("Type.Name", "double")] + [NativeName("Name", "Input")] + public double Input; + + [NativeName("Type", "double")] + [NativeName("Type.Name", "double")] + [NativeName("Name", "Output")] + public double Output; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs new file mode 100644 index 0000000000..8a69c586e4 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs @@ -0,0 +1,72 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + [NativeName("Name", "WICRect")] + public unsafe partial struct WICRect + { + public WICRect + ( + int? x = null, + int? y = null, + int? width = null, + int? height = null + ) : this() + { + if (x is not null) + { + X = x.Value; + } + + if (y is not null) + { + Y = y.Value; + } + + if (width is not null) + { + Width = width.Value; + } + + if (height is not null) + { + Height = height.Value; + } + } + + + [NativeName("Type", "INT")] + [NativeName("Type.Name", "INT")] + [NativeName("Name", "X")] + public int X; + + [NativeName("Type", "INT")] + [NativeName("Type.Name", "INT")] + [NativeName("Name", "Y")] + public int Y; + + [NativeName("Type", "INT")] + [NativeName("Type.Name", "INT")] + [NativeName("Name", "Width")] + public int Width; + + [NativeName("Type", "INT")] + [NativeName("Type.Name", "INT")] + [NativeName("Name", "Height")] + public int Height; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamProviderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamProviderVtblExtensions.gen.cs new file mode 100644 index 0000000000..a874f72f39 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamProviderVtblExtensions.gen.cs @@ -0,0 +1,217 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICStreamProviderVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int GetStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream** ppIStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ppIStream); + return ret; + } + + /// To be documented. + public static unsafe int GetStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream* ppIStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppIStreamPtr = &ppIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ppIStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPersistOptions(this ComPtr thisVtbl, uint* pdwPersistOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pdwPersistOptions); + return ret; + } + + /// To be documented. + public static int GetPersistOptions(this ComPtr thisVtbl, ref uint pdwPersistOptions) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pdwPersistOptionsPtr = &pdwPersistOptions) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pdwPersistOptionsPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int GetPreferredVendorGUID(this ComPtr thisVtbl, Guid* pguidPreferredVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidPreferredVendor); + return ret; + } + + /// To be documented. + public static int GetPreferredVendorGUID(this ComPtr thisVtbl, ref Guid pguidPreferredVendor) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* pguidPreferredVendorPtr = &pguidPreferredVendor) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pguidPreferredVendorPtr); + } + return ret; + } + + /// To be documented. + public static int RefreshStream(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this); + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static int GetStream(this ComPtr thisVtbl, ref ComPtr ppIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->GetStream((Silk.NET.Core.Win32Extras.IStream**) ppIStream.GetAddressOf()); + } + + /// To be documented. + public static int GetPersistOptions(this ComPtr thisVtbl, Span pdwPersistOptions) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPersistOptions(ref pdwPersistOptions.GetPinnableReference()); + } + + /// To be documented. + public static int GetPreferredVendorGUID(this ComPtr thisVtbl, Span pguidPreferredVendor) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->GetPreferredVendorGUID(ref pguidPreferredVendor.GetPinnableReference()); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamVtblExtensions.gen.cs new file mode 100644 index 0000000000..23c9e21bf9 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICStreamVtblExtensions.gen.cs @@ -0,0 +1,747 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + + +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs; + +public unsafe static class WICStreamVtblExtensions +{ + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObject); + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Guid* riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riid, ppvObjectPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObject); + } + return ret; + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, ref Guid riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Guid* riidPtr = &riid) + { + fixed (void** ppvObjectPtr = &ppvObject) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[0])(@this, riidPtr, ppvObjectPtr); + } + } + return ret; + } + + /// To be documented. + public static uint AddRef(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[1])(@this); + return ret; + } + + /// To be documented. + public static uint Release(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + uint ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[2])(@this); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, void* pv, uint cb, uint* pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pv, cb, pcbRead); + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, void* pv, uint cb, ref uint pcbRead) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pv, cb, pcbReadPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, ref T0 pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pvPtr, cb, pcbRead); + } + return ret; + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, ref T0 pv, uint cb, ref uint pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pvPtr, cb, pcbReadPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, uint* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pv, cb, pcbWritten); + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, ref uint pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pv, cb, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pvPtr, cb, pcbWritten); + } + return ret; + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in T0 pv, uint cb, ref uint pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (void* pvPtr = &pv) + { + fixed (uint* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pvPtr, cb, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int Seek(this ComPtr thisVtbl, long dlibMove, uint dwOrigin, ulong* plibNewPosition) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, dlibMove, dwOrigin, plibNewPosition); + return ret; + } + + /// To be documented. + public static int Seek(this ComPtr thisVtbl, long dlibMove, uint dwOrigin, ref ulong plibNewPosition) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* plibNewPositionPtr = &plibNewPosition) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, dlibMove, dwOrigin, plibNewPositionPtr); + } + return ret; + } + + /// To be documented. + public static int SetSize(this ComPtr thisVtbl, ulong libNewSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, libNewSize); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbRead, pcbWritten); + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbRead, pcbWrittenPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbReadPtr, pcbWritten); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (ulong* pcbReadPtr = &pcbRead) + { + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstm, cb, pcbReadPtr, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbRead, pcbWritten); + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbRead, pcbWrittenPtr); + } + } + return ret; + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + fixed (ulong* pcbReadPtr = &pcbRead) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbReadPtr, pcbWritten); + } + } + return ret; + } + + /// To be documented. + public static int CopyTo(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pstmPtr = &pstm) + { + fixed (ulong* pcbReadPtr = &pcbRead) + { + fixed (ulong* pcbWrittenPtr = &pcbWritten) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pstmPtr, cb, pcbReadPtr, pcbWrittenPtr); + } + } + } + return ret; + } + + /// To be documented. + public static int Commit(this ComPtr thisVtbl, uint grfCommitFlags) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, grfCommitFlags); + return ret; + } + + /// To be documented. + public static int Revert(this ComPtr thisVtbl) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this); + return ret; + } + + /// To be documented. + public static int LockRegion(this ComPtr thisVtbl, ulong libOffset, ulong cb, uint dwLockType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public static int UnlockRegion(this ComPtr thisVtbl, ulong libOffset, ulong cb, uint dwLockType) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, libOffset, cb, dwLockType); + return ret; + } + + /// To be documented. + public static unsafe int Stat(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.STATSTG* pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pstatstg, grfStatFlag); + return ret; + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.STATSTG pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.STATSTG* pstatstgPtr = &pstatstg) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, pstatstgPtr, grfStatFlag); + } + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream** ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppstm); + return ret; + } + + /// To be documented. + public static unsafe int Clone(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream* ppstm) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream** ppstmPtr = &ppstm) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[13])(@this, ppstmPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromIStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, pIStream); + return ret; + } + + /// To be documented. + public static int InitializeFromIStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[14])(@this, pIStreamPtr); + } + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFileName, uint dwDesiredAccess) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, wzFileName, dwDesiredAccess); + return ret; + } + + /// To be documented. + public static int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFileName, uint dwDesiredAccess) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (char* wzFileNamePtr = &wzFileName) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, wzFileNamePtr, dwDesiredAccess); + } + return ret; + } + + /// To be documented. + public static int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFileName, uint dwDesiredAccess) + { + var @this = thisVtbl.Handle; + int ret = default; + var wzFileNamePtr = (byte*) SilkMarshal.StringToPtr(wzFileName, NativeStringEncoding.LPWStr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[15])(@this, wzFileNamePtr, dwDesiredAccess); + SilkMarshal.Free((nint)wzFileNamePtr); + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromMemory(this ComPtr thisVtbl, byte* pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pbBuffer, cbBufferSize); + return ret; + } + + /// To be documented. + public static int InitializeFromMemory(this ComPtr thisVtbl, ref byte pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (byte* pbBufferPtr = &pbBuffer) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pbBufferPtr, cbBufferSize); + } + return ret; + } + + /// To be documented. + public static int InitializeFromMemory(this ComPtr thisVtbl, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + int ret = default; + var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[16])(@this, pbBufferPtr, cbBufferSize); + SilkMarshal.Free((nint)pbBufferPtr); + return ret; + } + + /// To be documented. + public static unsafe int InitializeFromIStreamRegion(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, ulong ulOffset, ulong ulMaxSize) + { + var @this = thisVtbl.Handle; + int ret = default; + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pIStream, ulOffset, ulMaxSize); + return ret; + } + + /// To be documented. + public static int InitializeFromIStreamRegion(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, ulong ulOffset, ulong ulMaxSize) + { + var @this = thisVtbl.Handle; + int ret = default; + fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) + { + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pIStreamPtr, ulOffset, ulMaxSize); + } + return ret; + } + + /// To be documented. + public static int QueryInterface(this ComPtr thisVtbl, out ComPtr ppvObject) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + ppvObject = default; + return @this->QueryInterface(SilkMarshal.GuidPtrOf(), (void**) ppvObject.GetAddressOf()); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, void** ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ppvObject); + } + + /// To be documented. + public static unsafe int QueryInterface(this ComPtr thisVtbl, Span riid, ref void* ppvObject) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->QueryInterface(ref riid.GetPinnableReference(), ref ppvObject); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, void* pv, uint cb, Span pcbRead) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(pv, cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Read(this ComPtr thisVtbl, Span pv, uint cb, uint* pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(ref pv.GetPinnableReference(), cb, pcbRead); + } + + /// To be documented. + public static int Read(this ComPtr thisVtbl, Span pv, uint cb, Span pcbRead) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Read(ref pv.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] void* pv, uint cb, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(pv, cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, uint* pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(in pv.GetPinnableReference(), cb, pcbWritten); + } + + /// To be documented. + public static int Write(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pv, uint cb, Span pcbWritten) where T0 : unmanaged + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Write(in pv.GetPinnableReference(), cb, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static int Seek(this ComPtr thisVtbl, long dlibMove, uint dwOrigin, Span plibNewPosition) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Seek(dlibMove, dwOrigin, ref plibNewPosition.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, ComPtr pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, pcbWritten); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, ulong* pcbRead, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(pstm, cb, pcbRead, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, ComPtr pstm, ulong cb, ulong* pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, pcbRead, ref pcbWritten); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, Span pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(pstm, cb, ref pcbRead.GetPinnableReference(), pcbWritten); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, ComPtr pstm, ulong cb, ref ulong pcbRead, ulong* pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, pcbWritten); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pstm, ulong cb, Span pcbRead, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(pstm, cb, ref pcbRead.GetPinnableReference(), ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static int CopyTo(this ComPtr thisVtbl, ComPtr pstm, ulong cb, ref ulong pcbRead, ref ulong pcbWritten) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->CopyTo((Silk.NET.Core.Win32Extras.IStream*) pstm.Handle, cb, ref pcbRead, ref pcbWritten); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Span pstm, ulong cb, ulong* pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ref pstm.GetPinnableReference(), cb, pcbRead, pcbWritten); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Span pstm, ulong cb, ulong* pcbRead, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ref pstm.GetPinnableReference(), cb, pcbRead, ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static unsafe int CopyTo(this ComPtr thisVtbl, Span pstm, ulong cb, Span pcbRead, ulong* pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ref pstm.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference(), pcbWritten); + } + + /// To be documented. + public static int CopyTo(this ComPtr thisVtbl, Span pstm, ulong cb, Span pcbRead, Span pcbWritten) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->CopyTo(ref pstm.GetPinnableReference(), cb, ref pcbRead.GetPinnableReference(), ref pcbWritten.GetPinnableReference()); + } + + /// To be documented. + public static int Stat(this ComPtr thisVtbl, Span pstatstg, uint grfStatFlag) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->Stat(ref pstatstg.GetPinnableReference(), grfStatFlag); + } + + /// To be documented. + public static int Clone(this ComPtr thisVtbl, ref ComPtr ppstm) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->Clone((Silk.NET.Core.Win32Extras.IStream**) ppstm.GetAddressOf()); + } + + /// To be documented. + public static int InitializeFromIStream(this ComPtr thisVtbl, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->InitializeFromIStream((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + } + + /// To be documented. + public static int InitializeFromIStream(this ComPtr thisVtbl, Span pIStream) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromIStream(ref pIStream.GetPinnableReference()); + } + + /// To be documented. + public static int InitializeFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFileName, uint dwDesiredAccess) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromFilename(in wzFileName.GetPinnableReference(), dwDesiredAccess); + } + + /// To be documented. + public static int InitializeFromMemory(this ComPtr thisVtbl, Span pbBuffer, uint cbBufferSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromMemory(ref pbBuffer.GetPinnableReference(), cbBufferSize); + } + + /// To be documented. + public static int InitializeFromIStreamRegion(this ComPtr thisVtbl, ComPtr pIStream, ulong ulOffset, ulong ulMaxSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + var @this = thisVtbl.Handle; + // ComPtrOverloader + return @this->InitializeFromIStreamRegion((Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ulOffset, ulMaxSize); + } + + /// To be documented. + public static int InitializeFromIStreamRegion(this ComPtr thisVtbl, Span pIStream, ulong ulOffset, ulong ulMaxSize) + { + var @this = thisVtbl.Handle; + // SpanOverloader + return @this->InitializeFromIStreamRegion(ref pIStream.GetPinnableReference(), ulOffset, ulMaxSize); + } + + /// To be documented. + public static ComPtr QueryInterface(this ComPtr thisVtbl) where TI0 : unmanaged, IComVtbl + { + var @this = thisVtbl.Handle; + // NonKhrReturnTypeOverloader + SilkMarshal.ThrowHResult(@this->QueryInterface(out ComPtr silkRet)); + return silkRet; + } + +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WICLibraryNameContainer.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WICLibraryNameContainer.cs new file mode 100644 index 0000000000..c9c22dcec8 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WICLibraryNameContainer.cs @@ -0,0 +1,31 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Silk.NET.Core.Loader; + +namespace Silk.NET.WindowsCodecs +{ + /// + /// Contains the library name of WindowsCodecs. + /// + internal class WICLibraryNameContainer : SearchPathContainer + { + /// + public override string[] Linux => new[] { "libwindowscodecs.so" }; + + /// + public override string[] MacOS => new[] { "libwindowscodecs.dylib" }; + + /// + public override string[] Android => new[] { "libwindowscodecs.so" }; + + /// + public override string[] IOS => new[] { "__Internal" }; + + /// + public override string[] Windows64 => new[] { "windowscodecs.dll" }; + + /// + public override string[] Windows86 => new[] { "windowscodecs.dll" }; + } +} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.cs new file mode 100644 index 0000000000..2244a05de3 --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.cs @@ -0,0 +1,38 @@ +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; +using static Silk.NET.Core.Attributes.ExtensionAttribute; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + public partial class WindowsCodecs + { + public static WindowsCodecs GetApi() + { + return new(CreateDefaultContext(new WICLibraryNameContainer().GetLibraryNames())); + } + + public bool TryGetExtension(out T ext) + where T:NativeExtension + { + ext = IsExtensionPresent(GetExtensionAttribute(typeof(T)).Name) + ? (T) Activator.CreateInstance(typeof(T), Context) + : null; + return ext is not null; + } + + public override bool IsExtensionPresent(string extension) + { + throw new NotImplementedException(); + } + } +} + diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs new file mode 100644 index 0000000000..244ece452d --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs @@ -0,0 +1,6011 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + public unsafe partial class WindowsCodecs : NativeAPI + { + [NativeName("Type", "int")] + [NativeName("Name", "WINCODEC_SDK_VERSION1")] + public const int WincodecSdkVersion1 = unchecked((int) 0x236); + [NativeName("Type", "int")] + [NativeName("Name", "WINCODEC_SDK_VERSION2")] + public const int WincodecSdkVersion2 = unchecked((int) 0x237); + [NativeName("Type", "int")] + [NativeName("Name", "WINCODEC_SDK_VERSION")] + public const int WincodecSdkVersion = unchecked((int) 0x237); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_MAX_COMPONENT_COUNT")] + public const int JpegMaxComponentCount = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_MAX_TABLE_INDEX")] + public const int JpegMaxTableIndex = unchecked((int) 0x3); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_SAMPLE_FACTORS_ONE")] + public const int JpegSampleFactorsOne = unchecked((int) 0x11); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_SAMPLE_FACTORS_THREE_420")] + public const int JpegSampleFactorsThree420 = unchecked((int) 0x111122); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_SAMPLE_FACTORS_THREE_422")] + public const int JpegSampleFactorsThree422 = unchecked((int) 0x111121); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_SAMPLE_FACTORS_THREE_440")] + public const int JpegSampleFactorsThree440 = unchecked((int) 0x111112); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_SAMPLE_FACTORS_THREE_444")] + public const int JpegSampleFactorsThree444 = unchecked((int) 0x111111); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_QUANTIZATION_BASELINE_ONE")] + public const int JpegQuantizationBaselineOne = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_QUANTIZATION_BASELINE_THREE")] + public const int JpegQuantizationBaselineThree = unchecked((int) 0x10100); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_HUFFMAN_BASELINE_ONE")] + public const int JpegHuffmanBaselineOne = unchecked((int) 0x0); + [NativeName("Type", "int")] + [NativeName("Name", "WIC_JPEG_HUFFMAN_BASELINE_THREE")] + public const int JpegHuffmanBaselineThree = unchecked((int) 0x111100); + [NativeName("Type", "int")] + [NativeName("Name", "FACILITY_WINCODEC_ERR")] + public const int FacilityWincodecErr = unchecked((int) 0x898); + [NativeName("Type", "int")] + [NativeName("Name", "WINCODEC_ERR_BASE")] + public const int WincodecErrBase = unchecked((int) 0x2000); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_ExposureCompensation")] + public const int WicrawChangeNotificationExposureCompensation = unchecked((int) 0x1); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_NamedWhitePoint")] + public const int WicrawChangeNotificationNamedWhitePoint = unchecked((int) 0x2); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_KelvinWhitePoint")] + public const int WicrawChangeNotificationKelvinWhitePoint = unchecked((int) 0x4); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_RGBWhitePoint")] + public const int WicrawChangeNotificationRgbwhitePoint = unchecked((int) 0x8); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_Contrast")] + public const int WicrawChangeNotificationContrast = unchecked((int) 0x10); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_Gamma")] + public const int WicrawChangeNotificationGamma = unchecked((int) 0x20); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_Sharpness")] + public const int WicrawChangeNotificationSharpness = unchecked((int) 0x40); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_Saturation")] + public const int WicrawChangeNotificationSaturation = unchecked((int) 0x80); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_Tint")] + public const int WicrawChangeNotificationTint = unchecked((int) 0x100); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_NoiseReduction")] + public const int WicrawChangeNotificationNoiseReduction = unchecked((int) 0x200); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_DestinationColorContext")] + public const int WicrawChangeNotificationDestinationColorContext = unchecked((int) 0x400); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_ToneCurve")] + public const int WicrawChangeNotificationToneCurve = unchecked((int) 0x800); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_Rotation")] + public const int WicrawChangeNotificationRotation = unchecked((int) 0x1000); + [NativeName("Type", "int")] + [NativeName("Name", "WICRawChangeNotification_RenderMode")] + public const int WicrawChangeNotificationRenderMode = unchecked((int) 0x2000); + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(IWICBitmapCodecProgressNotification* This, IWICProgressCallback* pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(IWICBitmapCodecProgressNotification* This, ref IWICProgressCallback pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ref IWICBitmapCodecProgressNotification This, IWICProgressCallback* pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ref IWICBitmapCodecProgressNotification This, ref IWICProgressCallback pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_Remote_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICBitmapDecoderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, IWICBitmapSource** ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, ref IWICBitmapSource* ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, IWICBitmapSource** ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] + public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, ref IWICBitmapSource* ppIDst); + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap); + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] + public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public partial int WICMapGuidToShortName(ref Guid guid, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] + public partial int WICMapGuidToShortName(ref Guid guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Guid* pguid); + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Guid pguid); + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, Guid* pguid); + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] + public partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref Guid pguid); + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Guid* pguid); + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] + public partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref Guid pguid); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] + public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, WICRawCapabilitiesInfo* pInfo); + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, ref WICRawCapabilitiesInfo pInfo); + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, WICRawCapabilitiesInfo* pInfo); + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, ref WICRawCapabilitiesInfo pInfo); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawRemoteSetToneCurveProxy(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICDevelopRawRemoteSetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICDevelopRawRemoteGetToneCurveStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint BSTRUserSize(uint* arg0, uint arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint BSTRUserSize(uint* arg0, uint arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint BSTRUserSize(ref uint arg0, uint arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint BSTRUserSize(ref uint arg0, uint arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, byte* arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, byte* arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, ref byte arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, ref byte arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* BSTRUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "BSTR_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string BSTRUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2); + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void BSTRUserFree(uint* arg0, char** arg1); + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void BSTRUserFree(uint* arg0, ref char* arg1); + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void BSTRUserFree(ref uint arg0, char** arg1); + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "BSTR_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void BSTRUserFree(ref uint arg0, ref char* arg1); + + /// To be documented. + [NativeName("Src", "Line 8994, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HBITMAPUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8994, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HBITMAPUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8994, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HBITMAPUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8994, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HBITMAPUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HBITMAPUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HBITMAP_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HBITMAPUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8997, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HBITMAPUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 8997, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HBITMAPUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 8997, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HBITMAPUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 8997, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HBITMAP_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HBITMAPUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 8999, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HICONUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8999, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HICONUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 8999, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HICONUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 8999, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HICONUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HICONUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HICON_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HICONUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9002, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HICONUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 9002, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HICONUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 9002, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HICONUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 9002, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HICON_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HICONUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 9004, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HPALETTEUserSize(uint* arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9004, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HPALETTEUserSize(uint* arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9004, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HPALETTEUserSize(ref uint arg0, uint arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9004, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint HPALETTEUserSize(ref uint arg0, uint arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, byte* arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, byte* arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, ref byte arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, ref byte arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* HPALETTEUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "HPALETTE_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string HPALETTEUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2); + + /// To be documented. + [NativeName("Src", "Line 9007, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HPALETTEUserFree(uint* arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 9007, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HPALETTEUserFree(uint* arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 9007, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HPALETTEUserFree(ref uint arg0, void** arg1); + + /// To be documented. + [NativeName("Src", "Line 9007, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "HPALETTE_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void HPALETTEUserFree(ref uint arg0, ref void* arg1); + + /// To be documented. + [NativeName("Src", "Line 9009, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint LPSAFEARRAYUserSize(uint* arg0, uint arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9009, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint LPSAFEARRAYUserSize(uint* arg0, uint arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9009, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint LPSAFEARRAYUserSize(ref uint arg0, uint arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9009, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint LPSAFEARRAYUserSize(ref uint arg0, uint arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, ref byte arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, ref byte arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* LPSAFEARRAYUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string LPSAFEARRAYUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2); + + /// To be documented. + [NativeName("Src", "Line 9012, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void LPSAFEARRAYUserFree(uint* arg0, Silk.NET.Core.Win32Extras.SafeArray** arg1); + + /// To be documented. + [NativeName("Src", "Line 9012, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void LPSAFEARRAYUserFree(uint* arg0, ref Silk.NET.Core.Win32Extras.SafeArray* arg1); + + /// To be documented. + [NativeName("Src", "Line 9012, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void LPSAFEARRAYUserFree(ref uint arg0, Silk.NET.Core.Win32Extras.SafeArray** arg1); + + /// To be documented. + [NativeName("Src", "Line 9012, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "LPSAFEARRAY_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void LPSAFEARRAYUserFree(ref uint arg0, ref Silk.NET.Core.Win32Extras.SafeArray* arg1); + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint WICInProcPointerUserSize(uint* arg0, uint arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint WICInProcPointerUserSize(uint* arg0, uint arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint WICInProcPointerUserSize(ref uint arg0, uint arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint WICInProcPointerUserSize(ref uint arg0, uint arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void WICInProcPointerUserFree(uint* arg0, byte** arg1); + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void WICInProcPointerUserFree(uint* arg0, ref byte* arg1); + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void WICInProcPointerUserFree(ref uint arg0, byte** arg1); + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void WICInProcPointerUserFree(ref uint arg0, ref byte* arg1); + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(IWICBitmapCodecProgressNotification* This, PfnProgressNotification pfnProgressNotification, void* pvData, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(IWICBitmapCodecProgressNotification* This, PfnProgressNotification pfnProgressNotification, ref T0 pvData, uint dwProgressFlags) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(ref IWICBitmapCodecProgressNotification This, PfnProgressNotification pfnProgressNotification, void* pvData, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(ref IWICBitmapCodecProgressNotification This, PfnProgressNotification pfnProgressNotification, ref T0 pvData, uint dwProgressFlags) where T0 : unmanaged; + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(IWICBitmapCodecProgressNotification* This, IWICProgressCallback* pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(IWICBitmapCodecProgressNotification* This, ref IWICProgressCallback pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ref IWICBitmapCodecProgressNotification This, IWICProgressCallback* pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapCodecProgressNotification_RegisterProgressNotification_Stub", Convention = CallingConvention.StdCall)] + public partial int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ref IWICBitmapCodecProgressNotification This, ref IWICProgressCallback pICallback, uint dwProgressFlags); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, WICRawCapabilitiesInfo* pInfo); + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, ref WICRawCapabilitiesInfo pInfo); + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, WICRawCapabilitiesInfo* pInfo); + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, ref WICRawCapabilitiesInfo pInfo); + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(IWICDevelopRaw* This, WICRawCapabilitiesInfo* pInfo); + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(IWICDevelopRaw* This, ref WICRawCapabilitiesInfo pInfo); + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(ref IWICDevelopRaw This, WICRawCapabilitiesInfo* pInfo); + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(ref IWICDevelopRaw This, ref WICRawCapabilitiesInfo pInfo); + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawSetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve); + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawSetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve); + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawSetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve); + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawSetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve); + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawSetToneCurveStub(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawSetToneCurveStub(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawSetToneCurveStub(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawSetToneCurveStub(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICMetadataReaderInfoRemoteGetPatternsStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, uint* _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public partial void IWICMetadataWriterInfoRemoteGetHeaderStub(ref Silk.NET.Core.Win32Extras.IRpcStubBuffer This, ref Silk.NET.Core.Win32Extras.IRpcChannelBuffer _pRpcChannelBuffer, ref Silk.NET.Core.Win32Extras.RPCMessage _pRpcMessage, ref uint _pdwStubPhase); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] + public partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public unsafe partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] + public partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ref ulong pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, ulong* pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, ref ulong pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, ref ulong pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public unsafe partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, ulong* pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] + public partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, ref ulong pcbSize); + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint CLIPFORMATUserSize(uint* arg0, uint arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint CLIPFORMATUserSize(uint* arg0, uint arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize", Convention = CallingConvention.StdCall)] + public unsafe partial uint CLIPFORMATUserSize(ref uint arg0, uint arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserSize", Convention = CallingConvention.StdCall)] + public partial uint CLIPFORMATUserSize(ref uint arg0, uint arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public partial string CLIPFORMATUserMarshalS(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserMarshal", Convention = CallingConvention.StdCall)] + public partial string CLIPFORMATUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, byte* arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, byte* arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, ref byte arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public partial string CLIPFORMATUserUnmarshalS(ref uint arg0, ref byte arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial string CLIPFORMATUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public unsafe partial byte* CLIPFORMATUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + [NativeApi(EntryPoint = "CLIPFORMAT_UserUnmarshal", Convention = CallingConvention.StdCall)] + public partial string CLIPFORMATUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref ushort arg2); + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void CLIPFORMATUserFree(uint* arg0, ushort* arg1); + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void CLIPFORMATUserFree(uint* arg0, ref ushort arg1); + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree", Convention = CallingConvention.StdCall)] + public unsafe partial void CLIPFORMATUserFree(ref uint arg0, ushort* arg1); + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + [NativeApi(EntryPoint = "CLIPFORMAT_UserFree", Convention = CallingConvention.StdCall)] + public partial void CLIPFORMATUserFree(ref uint arg0, ref ushort arg1); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] + public partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] + public partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ComPtr This, ComPtr pICallback, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy((IWICBitmapCodecProgressNotification*) This.Handle, (IWICProgressCallback*) pICallback.Handle, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ComPtr This, ref IWICProgressCallback pICallback, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy((IWICBitmapCodecProgressNotification*) This.Handle, ref pICallback, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ref IWICBitmapCodecProgressNotification This, ComPtr pICallback, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ref This, (IWICProgressCallback*) pICallback.Handle, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, WICBitmapPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, WICBitmapPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public unsafe int WICConvertBitmapSource(Guid* dstFormat, ComPtr pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICConvertBitmapSource(dstFormat, (IWICBitmapSource*) pISrc.Handle, (IWICBitmapSource**) ppIDst.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public unsafe int WICConvertBitmapSource(Guid* dstFormat, ComPtr pISrc, ref IWICBitmapSource* ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICConvertBitmapSource(dstFormat, (IWICBitmapSource*) pISrc.Handle, ref ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public unsafe int WICConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICConvertBitmapSource(dstFormat, ref pISrc, (IWICBitmapSource**) ppIDst.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public unsafe int WICConvertBitmapSource(ref Guid dstFormat, ComPtr pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICConvertBitmapSource(ref dstFormat, (IWICBitmapSource*) pISrc.Handle, (IWICBitmapSource**) ppIDst.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public unsafe int WICConvertBitmapSource(ref Guid dstFormat, ComPtr pISrc, ref IWICBitmapSource* ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICConvertBitmapSource(ref dstFormat, (IWICBitmapSource*) pISrc.Handle, ref ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public unsafe int WICConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICConvertBitmapSource(ref dstFormat, ref pISrc, (IWICBitmapSource**) ppIDst.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSection(width, height, pixelFormat, hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSection(width, height, pixelFormat, ref hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSection(width, height, ref pixelFormat, hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSection(width, height, ref pixelFormat, ref hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSectionEx(width, height, pixelFormat, hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSectionEx(width, height, ref pixelFormat, hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICCreateBitmapFromSectionEx(width, height, ref pixelFormat, ref hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + } + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr This, WICRawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr This, ref WICRawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, ref pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cPoints, aPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cPoints, in aPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, uint* pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, pcPoints, paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, pcPoints, ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, ref uint pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, ref pcPoints, paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, ref pcPoints, ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + public unsafe uint BSTRUserSize(uint* arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserSize(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + public unsafe uint BSTRUserSize(ref uint arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserSize(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserMarshal(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserMarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserMarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserMarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserMarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserUnmarshal(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserUnmarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserUnmarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserUnmarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public unsafe byte* BSTRUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string BSTRUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (char**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = BSTRUserUnmarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + public unsafe void BSTRUserFree(uint* arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (char**) SilkMarshal.StringArrayToPtr(arg1Sa); + BSTRUserFree(arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + public unsafe void BSTRUserFree(ref uint arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (char**) SilkMarshal.StringArrayToPtr(arg1Sa); + BSTRUserFree(ref arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + public unsafe uint WICInProcPointerUserSize(uint* arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserSize(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + public unsafe uint WICInProcPointerUserSize(ref uint arg0, uint arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserSize(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserMarshal(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserMarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshal(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshalS(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserMarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserMarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshal(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshalS(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserMarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserUnmarshal(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserUnmarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshal(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshalS(arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshal(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshalS(arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserUnmarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshal(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshalS(ref arg0, ref arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public unsafe byte* WICInProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshal(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] + public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + { + // StringArrayOverloader + var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); + var ret = WICInProcPointerUserUnmarshalS(ref arg0, arg1, arg2); + SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); + SilkMarshal.Free((nint) arg2); + return ret; + } + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + public unsafe void WICInProcPointerUserFree(uint* arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (byte**) SilkMarshal.StringArrayToPtr(arg1Sa); + WICInProcPointerUserFree(arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + public unsafe void WICInProcPointerUserFree(ref uint arg0, string[] arg1Sa) + { + // StringArrayOverloader + var arg1 = (byte**) SilkMarshal.StringArrayToPtr(arg1Sa); + WICInProcPointerUserFree(ref arg0, arg1); + SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); + SilkMarshal.Free((nint) arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(ComPtr This, PfnProgressNotification pfnProgressNotification, void* pvData, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy((IWICBitmapCodecProgressNotification*) This.Handle, pfnProgressNotification, pvData, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(ComPtr This, PfnProgressNotification pfnProgressNotification, ref T0 pvData, uint dwProgressFlags) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy((IWICBitmapCodecProgressNotification*) This.Handle, pfnProgressNotification, ref pvData, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ComPtr This, ComPtr pICallback, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub((IWICBitmapCodecProgressNotification*) This.Handle, (IWICProgressCallback*) pICallback.Handle, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ComPtr This, ref IWICProgressCallback pICallback, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub((IWICBitmapCodecProgressNotification*) This.Handle, ref pICallback, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + public unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ref IWICBitmapCodecProgressNotification This, ComPtr pICallback, uint dwProgressFlags) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ref This, (IWICProgressCallback*) pICallback.Handle, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, ref pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, ref pcPatterns, ref pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, pcPatterns, ref pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, ref pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, ref pcPatterns, ref pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, WICBitmapPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, WICBitmapPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr This, WICRawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr This, ref WICRawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, ref pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr This, WICRawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawQueryRawCapabilitiesInfoStub((IWICDevelopRaw*) This.Handle, pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr This, ref WICRawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawQueryRawCapabilitiesInfoStub((IWICDevelopRaw*) This.Handle, ref pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveSize, pToneCurve); + } + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveSize, in pToneCurve); + } + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawSetToneCurveStub((IWICDevelopRaw*) This.Handle, cPoints, aPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawSetToneCurveStub((IWICDevelopRaw*) This.Handle, cPoints, in aPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, ref pToneCurve, pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, ref pToneCurve, ref pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, pcPoints, paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, pcPoints, ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, ref pcPoints, paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, ref pcPoints, ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, ref pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, ref pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(ref guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(ref guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(ref guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICMatchMetadataContent(ref guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public unsafe int WICSerializeMetadataContent(Guid* guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICSerializeMetadataContent(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public unsafe int WICSerializeMetadataContent(Guid* guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICSerializeMetadataContent(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, ref pIStream); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public unsafe int WICSerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICSerializeMetadataContent(guidContainerFormat, ref pIWriter, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public unsafe int WICSerializeMetadataContent(ref Guid guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICSerializeMetadataContent(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public unsafe int WICSerializeMetadataContent(ref Guid guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICSerializeMetadataContent(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, ref pIStream); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public unsafe int WICSerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICSerializeMetadataContent(ref guidContainerFormat, ref pIWriter, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public unsafe int WICGetMetadataContentSize(Guid* guidContainerFormat, ComPtr pIWriter, ulong* pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICGetMetadataContentSize(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public unsafe int WICGetMetadataContentSize(Guid* guidContainerFormat, ComPtr pIWriter, ref ulong pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICGetMetadataContentSize(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, ref pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public unsafe int WICGetMetadataContentSize(ref Guid guidContainerFormat, ComPtr pIWriter, ulong* pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICGetMetadataContentSize(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public unsafe int WICGetMetadataContentSize(ref Guid guidContainerFormat, ComPtr pIWriter, ref ulong pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return WICGetMetadataContentSize(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, ref pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, ref pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, ref pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, ref pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, ref pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, ref pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, ref pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, ref pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, ref pcCount, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, ref pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, pHeader, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, ref pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, ref pHeader, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, pHeader, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pHeader, ref pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, ref pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + { + // ComPtrOverloader + return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, ref pHeader); + } + + + public WindowsCodecs(INativeContext ctx) + : base(ctx) + { + } + } +} + diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs new file mode 100644 index 0000000000..460bf765ab --- /dev/null +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs @@ -0,0 +1,4061 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System; +using System.Runtime.InteropServices; +using System.Runtime.CompilerServices; +using System.Text; +using Silk.NET.Core; +using Silk.NET.Core.Native; +using Silk.NET.Core.Attributes; +using Silk.NET.Core.Contexts; +using Silk.NET.Core.Loader; + +#pragma warning disable 1591 + +namespace Silk.NET.WindowsCodecs +{ + public static class WindowsCodecsOverloads + { + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(this WindowsCodecs thisApi, IWICBitmapCodecProgressNotification* This, Span pICallback, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(This, ref pICallback.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(this WindowsCodecs thisApi, Span This, IWICProgressCallback* pICallback, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ref This.GetPinnableReference(), pICallback, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(this WindowsCodecs thisApi, Span This, Span pICallback, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationProxy(ref This.GetPinnableReference(), ref pICallback.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 4974, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotificationStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(This, ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(This, ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] + public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICBitmapDecoderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Guid* dstFormat, Span pISrc, IWICBitmapSource** ppIDst) + { + // SpanOverloader + return thisApi.WICConvertBitmapSource(dstFormat, ref pISrc.GetPinnableReference(), ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Guid* dstFormat, Span pISrc, ref IWICBitmapSource* ppIDst) + { + // SpanOverloader + return thisApi.WICConvertBitmapSource(dstFormat, ref pISrc.GetPinnableReference(), ref ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst) + { + // SpanOverloader + return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), pISrc, ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst) + { + // SpanOverloader + return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), pISrc, ref ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, Span pISrc, IWICBitmapSource** ppIDst) + { + // SpanOverloader + return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), ref pISrc.GetPinnableReference(), ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] + public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, Span pISrc, ref IWICBitmapSource* ppIDst) + { + // SpanOverloader + return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), ref pISrc.GetPinnableReference(), ref ppIDst); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSection(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSection(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, ref ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, ref ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, ref ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ref ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, desiredAccessLevel, ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, desiredAccessLevel, ref ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] + public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + { + // SpanOverloader + return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ref ppIBitmap); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(guid, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(guid, cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(guid, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(guid, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, char* wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] + public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pguid) + { + // SpanOverloader + return thisApi.WICMapShortNameToGuid(wzName, ref pguid.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Guid* pguid) + { + // SpanOverloader + return thisApi.WICMapShortNameToGuid(in wzName.GetPinnableReference(), pguid); + } + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pguid) + { + // SpanOverloader + return thisApi.WICMapShortNameToGuid(in wzName.GetPinnableReference(), ref pguid.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] + public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pguid) + { + // SpanOverloader + return thisApi.WICMapShortNameToGuid(wzName, ref pguid.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + } + + /// To be documented. + [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] + public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + { + // SpanOverloader + return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(This, ref pInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, WICRawCapabilitiesInfo* pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, Span pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), ref pInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteSetToneCurveProxy(This, cPoints, in aPoints.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteSetToneCurveProxy(ref This.GetPinnableReference(), cPoints, aPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteSetToneCurveProxy(ref This.GetPinnableReference(), cPoints, in aPoints.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteSetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, WICRawToneCurvePoint** paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(This, ref pcPoints.GetPinnableReference(), paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(This, ref pcPoints.GetPinnableReference(), ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint* pcPoints, WICRawToneCurvePoint** paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), pcPoints, paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), pcPoints, ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, Span pcPoints, WICRawToneCurvePoint** paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] + public static unsafe void IWICDevelopRawRemoteGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICDevelopRawRemoteGetToneCurveStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + public static unsafe uint BSTRUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8989, Column 39 in wincodec.h")] + public static unsafe uint BSTRUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8990, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, char** arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8991, Column 29 in wincodec.h")] + public static unsafe byte* BSTRUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref char* arg2) + { + // SpanOverloader + return thisApi.BSTRUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + public static unsafe void BSTRUserFree(this WindowsCodecs thisApi, Span arg0, char** arg1) + { + // SpanOverloader + thisApi.BSTRUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 8992, Column 39 in wincodec.h")] + public static unsafe void BSTRUserFree(this WindowsCodecs thisApi, Span arg0, ref char* arg1) + { + // SpanOverloader + thisApi.BSTRUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 8994, Column 39 in wincodec.h")] + public static unsafe uint HBITMAPUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8994, Column 39 in wincodec.h")] + public static unsafe uint HBITMAPUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8995, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8996, Column 29 in wincodec.h")] + public static unsafe byte* HBITMAPUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HBITMAPUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8997, Column 39 in wincodec.h")] + public static unsafe void HBITMAPUserFree(this WindowsCodecs thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HBITMAPUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 8997, Column 39 in wincodec.h")] + public static unsafe void HBITMAPUserFree(this WindowsCodecs thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HBITMAPUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 8999, Column 39 in wincodec.h")] + public static unsafe uint HICONUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 8999, Column 39 in wincodec.h")] + public static unsafe uint HICONUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9000, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9001, Column 29 in wincodec.h")] + public static unsafe byte* HICONUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HICONUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9002, Column 39 in wincodec.h")] + public static unsafe void HICONUserFree(this WindowsCodecs thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HICONUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9002, Column 39 in wincodec.h")] + public static unsafe void HICONUserFree(this WindowsCodecs thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HICONUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9004, Column 39 in wincodec.h")] + public static unsafe uint HPALETTEUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9004, Column 39 in wincodec.h")] + public static unsafe uint HPALETTEUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9005, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, void** arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9006, Column 29 in wincodec.h")] + public static unsafe byte* HPALETTEUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref void* arg2) + { + // SpanOverloader + return thisApi.HPALETTEUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9007, Column 39 in wincodec.h")] + public static unsafe void HPALETTEUserFree(this WindowsCodecs thisApi, Span arg0, void** arg1) + { + // SpanOverloader + thisApi.HPALETTEUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9007, Column 39 in wincodec.h")] + public static unsafe void HPALETTEUserFree(this WindowsCodecs thisApi, Span arg0, ref void* arg1) + { + // SpanOverloader + thisApi.HPALETTEUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9009, Column 39 in wincodec.h")] + public static unsafe uint LPSAFEARRAYUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9009, Column 39 in wincodec.h")] + public static unsafe uint LPSAFEARRAYUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9010, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Silk.NET.Core.Win32Extras.SafeArray** arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9011, Column 29 in wincodec.h")] + public static unsafe byte* LPSAFEARRAYUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref Silk.NET.Core.Win32Extras.SafeArray* arg2) + { + // SpanOverloader + return thisApi.LPSAFEARRAYUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9012, Column 39 in wincodec.h")] + public static unsafe void LPSAFEARRAYUserFree(this WindowsCodecs thisApi, Span arg0, Silk.NET.Core.Win32Extras.SafeArray** arg1) + { + // SpanOverloader + thisApi.LPSAFEARRAYUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9012, Column 39 in wincodec.h")] + public static unsafe void LPSAFEARRAYUserFree(this WindowsCodecs thisApi, Span arg0, ref Silk.NET.Core.Win32Extras.SafeArray* arg1) + { + // SpanOverloader + thisApi.LPSAFEARRAYUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + public static unsafe uint WICInProcPointerUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] + public static unsafe uint WICInProcPointerUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] + public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2) + { + // SpanOverloader + return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + } + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + public static unsafe void WICInProcPointerUserFree(this WindowsCodecs thisApi, Span arg0, byte** arg1) + { + // SpanOverloader + thisApi.WICInProcPointerUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] + public static unsafe void WICInProcPointerUserFree(this WindowsCodecs thisApi, Span arg0, ref byte* arg1) + { + // SpanOverloader + thisApi.WICInProcPointerUserFree(ref arg0.GetPinnableReference(), ref arg1); + } + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(this WindowsCodecs thisApi, IWICBitmapCodecProgressNotification* This, PfnProgressNotification pfnProgressNotification, Span pvData, uint dwProgressFlags) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(This, pfnProgressNotification, ref pvData.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(this WindowsCodecs thisApi, Span This, PfnProgressNotification pfnProgressNotification, void* pvData, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(ref This.GetPinnableReference(), pfnProgressNotification, pvData, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(this WindowsCodecs thisApi, Span This, PfnProgressNotification pfnProgressNotification, Span pvData, uint dwProgressFlags) where T0 : unmanaged + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRegisterProgressNotificationProxy(ref This.GetPinnableReference(), pfnProgressNotification, ref pvData.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(this WindowsCodecs thisApi, IWICBitmapCodecProgressNotification* This, Span pICallback, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(This, ref pICallback.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, IWICProgressCallback* pICallback, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ref This.GetPinnableReference(), pICallback, dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9028, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(this WindowsCodecs thisApi, Span This, Span pICallback, uint dwProgressFlags) + { + // SpanOverloader + return thisApi.IWICBitmapCodecProgressNotificationRegisterProgressNotificationStub(ref This.GetPinnableReference(), ref pICallback.GetPinnableReference(), dwProgressFlags); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), pcbPatternsActual); + } + + /// To be documented. + [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsStub(This, ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsStub(This, ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoProxy(This, ref pInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, WICRawCapabilitiesInfo* pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, Span pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), ref pInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoStub(This, ref pInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, WICRawCapabilitiesInfo* pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), pInfo); + } + + /// To be documented. + [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span pInfo) + { + // SpanOverloader + return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), ref pInfo.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) + { + // SpanOverloader + return thisApi.IWICDevelopRawSetToneCurveProxy(This, cbToneCurveSize, in pToneCurve.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) + { + // SpanOverloader + return thisApi.IWICDevelopRawSetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveSize, pToneCurve); + } + + /// To be documented. + [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) + { + // SpanOverloader + return thisApi.IWICDevelopRawSetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveSize, in pToneCurve.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawSetToneCurveStub(This, cPoints, in aPoints.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawSetToneCurveStub(ref This.GetPinnableReference(), cPoints, aPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawSetToneCurveStub(ref This.GetPinnableReference(), cPoints, in aPoints.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(This, cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(This, cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(This, cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), ref pcbActualToneCurveBufferSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), pcbActualToneCurveBufferSize); + } + + /// To be documented. + [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), ref pcbActualToneCurveBufferSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, WICRawToneCurvePoint** paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveStub(This, ref pcPoints.GetPinnableReference(), paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveStub(This, ref pcPoints.GetPinnableReference(), ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, uint* pcPoints, WICRawToneCurvePoint** paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), pcPoints, paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), pcPoints, ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span pcPoints, WICRawToneCurvePoint** paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + { + // SpanOverloader + return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), ref paPoints); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataReaderInfoRemoteGetPatternsStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(This, guidContainerFormat, ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, WICMetadataHeader* pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataHeader* pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Silk.NET.Core.Win32Extras.IRpcStubBuffer* This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(This, ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Silk.NET.Core.Win32Extras.IRpcChannelBuffer* _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), _pRpcChannelBuffer, ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Silk.NET.Core.Win32Extras.RPCMessage* _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), _pRpcMessage, ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, uint* _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), _pdwStubPhase); + } + + /// To be documented. + [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] + public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this WindowsCodecs thisApi, Span This, Span _pRpcChannelBuffer, Span _pRpcMessage, Span _pdwStubPhase) + { + // SpanOverloader + thisApi.IWICMetadataWriterInfoRemoteGetHeaderStub(ref This.GetPinnableReference(), ref _pRpcChannelBuffer.GetPinnableReference(), ref _pRpcMessage.GetPinnableReference(), ref _pdwStubPhase.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, pguidVendor, pIStream, ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, pguidVendor, ref pIStream.GetPinnableReference(), pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, pguidVendor, ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), pIStream, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), pIStream, ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, pIStream, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, pIStream, ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref pIStream.GetPinnableReference(), pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), pIStream, pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), pIStream, ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), pguidMetadataFormat); + } + + /// To be documented. + [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] + public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Span pguidMetadataFormat) + { + // SpanOverloader + return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Span pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(guidContainerFormat, pIWriter, dwPersistOptions, ref pIStream.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(guidContainerFormat, ref pIWriter.GetPinnableReference(), dwPersistOptions, pIStream); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, uint dwPersistOptions, Span pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(guidContainerFormat, ref pIWriter.GetPinnableReference(), dwPersistOptions, ref pIStream.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), pIWriter, dwPersistOptions, pIStream); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Span pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), pIWriter, dwPersistOptions, ref pIStream.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), dwPersistOptions, pIStream); + } + + /// To be documented. + [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] + public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, uint dwPersistOptions, Span pIStream) + { + // SpanOverloader + return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), dwPersistOptions, ref pIStream.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, Span pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(guidContainerFormat, pIWriter, ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, ulong* pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(guidContainerFormat, ref pIWriter.GetPinnableReference(), pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, Span pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(guidContainerFormat, ref pIWriter.GetPinnableReference(), ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), pIWriter, pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, Span pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), pIWriter, ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, ulong* pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), pcbSize); + } + + /// To be documented. + [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] + public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, Span pcbSize) + { + // SpanOverloader + return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), ref pcbSize.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + public static unsafe uint CLIPFORMATUserSize(this WindowsCodecs thisApi, uint* arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + public static unsafe uint CLIPFORMATUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] + public static unsafe uint CLIPFORMATUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2426, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ushort* arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + } + + /// To be documented. + [NativeName("Src", "Line 2427, Column 29 in wincodecsdk.h")] + public static unsafe byte* CLIPFORMATUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + { + // SpanOverloader + return thisApi.CLIPFORMATUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + public static unsafe void CLIPFORMATUserFree(this WindowsCodecs thisApi, uint* arg0, Span arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree(arg0, ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + public static unsafe void CLIPFORMATUserFree(this WindowsCodecs thisApi, Span arg0, ushort* arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree(ref arg0.GetPinnableReference(), arg1); + } + + /// To be documented. + [NativeName("Src", "Line 2428, Column 39 in wincodecsdk.h")] + public static unsafe void CLIPFORMATUserFree(this WindowsCodecs thisApi, Span arg0, Span arg1) + { + // SpanOverloader + thisApi.CLIPFORMATUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); + } + + /// To be documented. + [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + { + // SpanOverloader + return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, guidContainerFormat, cbSize, pHeader, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pHeader, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), pcbActual); + } + + /// To be documented. + [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(This, guidContainerFormat, ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, WICMetadataHeader* pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(This, ref guidContainerFormat.GetPinnableReference(), pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(This, ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), guidContainerFormat, pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), guidContainerFormat, ref pHeader.GetPinnableReference()); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataHeader* pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), pHeader); + } + + /// To be documented. + [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, Span pHeader) + { + // SpanOverloader + return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); + } + + } +} + From f0b5d6b6f3cda6f0382f7f1b0c5d7ded600f1ddd Mon Sep 17 00:00:00 2001 From: Steven He Date: Sat, 23 Sep 2023 17:49:23 +0900 Subject: [PATCH 2/7] Use new enum generator --- build/cache/wic.json.gz | Bin 59823 -> 59823 bytes generator.json | 2 +- .../Enums/WIC8BIMIptcDigestProperties.gen.cs | 9 ---- .../Enums/WIC8BIMIptcProperties.gen.cs | 9 ---- .../WIC8BIMResolutionInfoProperties.gen.cs | 24 ---------- .../Enums/WICBitmapAlphaChannelOption.gen.cs | 12 ----- .../Enums/WICBitmapCreateCacheOption.gen.cs | 12 ----- .../Enums/WICBitmapDecoderCapabilities.gen.cs | 18 ------- .../Enums/WICBitmapDitherType.gen.cs | 33 ------------- .../Enums/WICBitmapEncoderCacheOption.gen.cs | 12 ----- .../Enums/WICBitmapInterpolationMode.gen.cs | 18 ------- .../Enums/WICBitmapLockFlags.gen.cs | 9 ---- .../Enums/WICBitmapPaletteType.gen.cs | 45 ------------------ .../Enums/WICBitmapTransformOptions.gen.cs | 21 -------- .../Enums/WICColorContextType.gen.cs | 9 ---- .../Enums/WICComponentEnumerateOptions.gen.cs | 18 ------- .../Enums/WICComponentSigning.gen.cs | 15 ------ .../Enums/WICComponentType.gen.cs | 24 ---------- .../Enums/WICDdsAlphaMode.gen.cs | 18 ------- .../Enums/WICDdsDimension.gen.cs | 15 ------ .../Enums/WICDecodeOptions.gen.cs | 9 ---- ...ICGifApplicationExtensionProperties.gen.cs | 9 ---- .../WICGifCommentExtensionProperties.gen.cs | 6 --- ...ifGraphicControlExtensionProperties.gen.cs | 18 ------- .../WICGifImageDescriptorProperties.gen.cs | 27 ----------- ...ifLogicalScreenDescriptorProperties.gen.cs | 30 ------------ .../Enums/WICHeifHdrProperties.gen.cs | 18 ------- .../Enums/WICHeifProperties.gen.cs | 6 --- .../Enums/WICJpegChrominanceProperties.gen.cs | 6 --- .../Enums/WICJpegCommentProperties.gen.cs | 6 --- .../Enums/WICJpegIndexingOptions.gen.cs | 9 ---- .../Enums/WICJpegLuminanceProperties.gen.cs | 6 --- .../Enums/WICJpegScanType.gen.cs | 12 ----- .../Enums/WICJpegTransferMatrix.gen.cs | 9 ---- .../WICJpegYCrCbSubsamplingOption.gen.cs | 18 ------- .../Enums/WICMetadataCreationOptions.gen.cs | 12 ----- .../Enums/WICNamedWhitePoint.gen.cs | 36 -------------- .../Enums/WICPersistOptions.gen.cs | 21 -------- ...WICPixelFormatNumericRepresentation.gen.cs | 21 -------- .../Enums/WICPlanarOptions.gen.cs | 9 ---- .../Enums/WICPngBkgdProperties.gen.cs | 6 --- .../Enums/WICPngChrmProperties.gen.cs | 27 ----------- .../Enums/WICPngFilterOption.gen.cs | 24 ---------- .../Enums/WICPngGamaProperties.gen.cs | 6 --- .../Enums/WICPngHistProperties.gen.cs | 6 --- .../Enums/WICPngIccpProperties.gen.cs | 9 ---- .../Enums/WICPngItxtProperties.gen.cs | 18 ------- .../Enums/WICPngSrgbProperties.gen.cs | 6 --- .../Enums/WICPngTimeProperties.gen.cs | 21 -------- .../Enums/WICProgressNotification.gen.cs | 15 ------ .../Enums/WICProgressOperation.gen.cs | 12 ----- .../Enums/WICRawCapabilities.gen.cs | 12 ----- .../Enums/WICRawParameterSet.gen.cs | 12 ----- .../Enums/WICRawRenderMode.gen.cs | 12 ----- .../Enums/WICRawRotationCapabilities.gen.cs | 15 ------ .../Enums/WICSectionAccessLevel.gen.cs | 9 ---- .../Enums/WICTiffCompressionOption.gen.cs | 27 ----------- .../Enums/WICWebpAnimProperties.gen.cs | 6 --- .../Enums/WICWebpAnmfProperties.gen.cs | 6 --- 59 files changed, 1 insertion(+), 859 deletions(-) diff --git a/build/cache/wic.json.gz b/build/cache/wic.json.gz index 2693ba649fcdb642cf56c15ebc74678f98721fa1..073473dbfc751e5b00a1fc3bc936c0d952782e6a 100644 GIT binary patch delta 56506 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⁢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 Fqe18@a`K=T- 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ɪJ~+kJ}z2gM(c`c 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 diff --git a/generator.json b/generator.json index 054063b14f..baacdb13cd 100644 --- a/generator.json +++ b/generator.json @@ -1552,7 +1552,7 @@ "controlDescriptors": [ "convert-windows-only", "typemap-native", - "no-pre-2.17-obsolete-enums", + "no-pre-2.18-obsolete-enums", "no-csproj", "no-extra-dir" ], diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs index 4e3eef1fb1..e30cad994c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcDigestProperties.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WIC8BIMIptcDigestProperties")] public enum WIC8BIMIptcDigestProperties : int { - [Obsolete("Deprecated in favour of \"PString\"")] - [NativeName("Name", "WIC8BIMIptcDigestPString")] - Wic8BimiptcDigestPString = 0x1, - [Obsolete("Deprecated in favour of \"IptcDigest\"")] - [NativeName("Name", "WIC8BIMIptcDigestIptcDigest")] - Wic8BimiptcDigestIptcDigest = 0x2, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WIC8BIMIptcDigestProperties_FORCE_DWORD")] - Wic8BimiptcDigestPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WIC8BIMIptcDigestPString")] PString = 0x1, [NativeName("Name", "WIC8BIMIptcDigestIptcDigest")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs index 98fbabe6ed..19ed9df380 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMIptcProperties.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WIC8BIMIptcProperties")] public enum WIC8BIMIptcProperties : int { - [Obsolete("Deprecated in favour of \"PString\"")] - [NativeName("Name", "WIC8BIMIptcPString")] - Wic8BimiptcPString = 0x0, - [Obsolete("Deprecated in favour of \"EmbeddedIptc\"")] - [NativeName("Name", "WIC8BIMIptcEmbeddedIPTC")] - Wic8BimiptcEmbeddedIptc = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WIC8BIMIptcProperties_FORCE_DWORD")] - Wic8BimiptcPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WIC8BIMIptcPString")] PString = 0x0, [NativeName("Name", "WIC8BIMIptcEmbeddedIPTC")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs index f6ec50e724..bf51e6db97 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WIC8BIMResolutionInfoProperties.gen.cs @@ -12,30 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WIC8BIMResolutionInfoProperties")] public enum WIC8BIMResolutionInfoProperties : int { - [Obsolete("Deprecated in favour of \"PString\"")] - [NativeName("Name", "WIC8BIMResolutionInfoPString")] - Wic8BimresolutionInfoPString = 0x1, - [Obsolete("Deprecated in favour of \"HResolution\"")] - [NativeName("Name", "WIC8BIMResolutionInfoHResolution")] - Wic8BimresolutionInfoHResolution = 0x2, - [Obsolete("Deprecated in favour of \"HResolutionUnit\"")] - [NativeName("Name", "WIC8BIMResolutionInfoHResolutionUnit")] - Wic8BimresolutionInfoHResolutionUnit = 0x3, - [Obsolete("Deprecated in favour of \"WidthUnit\"")] - [NativeName("Name", "WIC8BIMResolutionInfoWidthUnit")] - Wic8BimresolutionInfoWidthUnit = 0x4, - [Obsolete("Deprecated in favour of \"VResolution\"")] - [NativeName("Name", "WIC8BIMResolutionInfoVResolution")] - Wic8BimresolutionInfoVResolution = 0x5, - [Obsolete("Deprecated in favour of \"VResolutionUnit\"")] - [NativeName("Name", "WIC8BIMResolutionInfoVResolutionUnit")] - Wic8BimresolutionInfoVResolutionUnit = 0x6, - [Obsolete("Deprecated in favour of \"HeightUnit\"")] - [NativeName("Name", "WIC8BIMResolutionInfoHeightUnit")] - Wic8BimresolutionInfoHeightUnit = 0x7, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WIC8BIMResolutionInfoProperties_FORCE_DWORD")] - Wic8BimresolutionInfoPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WIC8BIMResolutionInfoPString")] PString = 0x1, [NativeName("Name", "WIC8BIMResolutionInfoHResolution")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs index 873630f200..dba8ced1b3 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapAlphaChannelOption")] public enum WICBitmapAlphaChannelOption : int { - [Obsolete("Deprecated in favour of \"BitmapUseAlpha\"")] - [NativeName("Name", "WICBitmapUseAlpha")] - WicbitmapUseAlpha = 0x0, - [Obsolete("Deprecated in favour of \"BitmapUsePremultipliedAlpha\"")] - [NativeName("Name", "WICBitmapUsePremultipliedAlpha")] - WicbitmapUsePremultipliedAlpha = 0x1, - [Obsolete("Deprecated in favour of \"BitmapIgnoreAlpha\"")] - [NativeName("Name", "WICBitmapIgnoreAlpha")] - WicbitmapIgnoreAlpha = 0x2, - [Obsolete("Deprecated in favour of \"ItmapalphachanneloptionsForceDword\"")] - [NativeName("Name", "WICBITMAPALPHACHANNELOPTIONS_FORCE_DWORD")] - WicbitmapalphachanneloptionsForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapUseAlpha")] BitmapUseAlpha = 0x0, [NativeName("Name", "WICBitmapUsePremultipliedAlpha")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs index d18dbe9d8c..7f3d1df914 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapCreateCacheOption")] public enum WICBitmapCreateCacheOption : int { - [Obsolete("Deprecated in favour of \"BitmapNoCache\"")] - [NativeName("Name", "WICBitmapNoCache")] - WicbitmapNoCache = 0x0, - [Obsolete("Deprecated in favour of \"BitmapCacheOnDemand\"")] - [NativeName("Name", "WICBitmapCacheOnDemand")] - WicbitmapCacheOnDemand = 0x1, - [Obsolete("Deprecated in favour of \"BitmapCacheOnLoad\"")] - [NativeName("Name", "WICBitmapCacheOnLoad")] - WicbitmapCacheOnLoad = 0x2, - [Obsolete("Deprecated in favour of \"ItmapcreatecacheoptionForceDword\"")] - [NativeName("Name", "WICBITMAPCREATECACHEOPTION_FORCE_DWORD")] - WicbitmapcreatecacheoptionForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapNoCache")] BitmapNoCache = 0x0, [NativeName("Name", "WICBitmapCacheOnDemand")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs index 264b85f991..b21c220065 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs @@ -15,24 +15,6 @@ public enum WICBitmapDecoderCapabilities : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilitySameEncoder\"")] - [NativeName("Name", "WICBitmapDecoderCapabilitySameEncoder")] - WicbitmapDecoderCapabilitySameEncoder = 0x1, - [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanDecodeAllImages\"")] - [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeAllImages")] - WicbitmapDecoderCapabilityCanDecodeAllImages = 0x2, - [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanDecodeSomeImages\"")] - [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeSomeImages")] - WicbitmapDecoderCapabilityCanDecodeSomeImages = 0x4, - [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanEnumerateMetadata\"")] - [NativeName("Name", "WICBitmapDecoderCapabilityCanEnumerateMetadata")] - WicbitmapDecoderCapabilityCanEnumerateMetadata = 0x8, - [Obsolete("Deprecated in favour of \"BitmapDecoderCapabilityCanDecodeThumbnail\"")] - [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeThumbnail")] - WicbitmapDecoderCapabilityCanDecodeThumbnail = 0x10, - [Obsolete("Deprecated in favour of \"ItmapdecodercapabilitiesForceDword\"")] - [NativeName("Name", "WICBITMAPDECODERCAPABILITIES_FORCE_DWORD")] - WicbitmapdecodercapabilitiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapDecoderCapabilitySameEncoder")] BitmapDecoderCapabilitySameEncoder = 0x1, [NativeName("Name", "WICBitmapDecoderCapabilityCanDecodeAllImages")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs index e26a80a463..588010c44c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs @@ -12,39 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapDitherType")] public enum WICBitmapDitherType : int { - [Obsolete("Deprecated in favour of \"BitmapDitherTypeNone\"")] - [NativeName("Name", "WICBitmapDitherTypeNone")] - WicbitmapDitherTypeNone = 0x0, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeSolid\"")] - [NativeName("Name", "WICBitmapDitherTypeSolid")] - WicbitmapDitherTypeSolid = 0x0, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeOrdered4x4\"")] - [NativeName("Name", "WICBitmapDitherTypeOrdered4x4")] - WicbitmapDitherTypeOrdered4x4 = 0x1, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeOrdered8x8\"")] - [NativeName("Name", "WICBitmapDitherTypeOrdered8x8")] - WicbitmapDitherTypeOrdered8x8 = 0x2, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeOrdered16x16\"")] - [NativeName("Name", "WICBitmapDitherTypeOrdered16x16")] - WicbitmapDitherTypeOrdered16x16 = 0x3, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeSpiral4x4\"")] - [NativeName("Name", "WICBitmapDitherTypeSpiral4x4")] - WicbitmapDitherTypeSpiral4x4 = 0x4, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeSpiral8x8\"")] - [NativeName("Name", "WICBitmapDitherTypeSpiral8x8")] - WicbitmapDitherTypeSpiral8x8 = 0x5, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeDualSpiral4x4\"")] - [NativeName("Name", "WICBitmapDitherTypeDualSpiral4x4")] - WicbitmapDitherTypeDualSpiral4x4 = 0x6, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeDualSpiral8x8\"")] - [NativeName("Name", "WICBitmapDitherTypeDualSpiral8x8")] - WicbitmapDitherTypeDualSpiral8x8 = 0x7, - [Obsolete("Deprecated in favour of \"BitmapDitherTypeErrorDiffusion\"")] - [NativeName("Name", "WICBitmapDitherTypeErrorDiffusion")] - WicbitmapDitherTypeErrorDiffusion = 0x8, - [Obsolete("Deprecated in favour of \"ItmapdithertypeForceDword\"")] - [NativeName("Name", "WICBITMAPDITHERTYPE_FORCE_DWORD")] - WicbitmapdithertypeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapDitherTypeNone")] BitmapDitherTypeNone = 0x0, [NativeName("Name", "WICBitmapDitherTypeSolid")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs index f50c33f58e..a62303e690 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapEncoderCacheOption")] public enum WICBitmapEncoderCacheOption : int { - [Obsolete("Deprecated in favour of \"BitmapEncoderCacheInMemory\"")] - [NativeName("Name", "WICBitmapEncoderCacheInMemory")] - WicbitmapEncoderCacheInMemory = 0x0, - [Obsolete("Deprecated in favour of \"BitmapEncoderCacheTempFile\"")] - [NativeName("Name", "WICBitmapEncoderCacheTempFile")] - WicbitmapEncoderCacheTempFile = 0x1, - [Obsolete("Deprecated in favour of \"BitmapEncoderNoCache\"")] - [NativeName("Name", "WICBitmapEncoderNoCache")] - WicbitmapEncoderNoCache = 0x2, - [Obsolete("Deprecated in favour of \"ItmapencodercacheoptionForceDword\"")] - [NativeName("Name", "WICBITMAPENCODERCACHEOPTION_FORCE_DWORD")] - WicbitmapencodercacheoptionForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapEncoderCacheInMemory")] BitmapEncoderCacheInMemory = 0x0, [NativeName("Name", "WICBitmapEncoderCacheTempFile")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs index ade8cbad1e..762723fab1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs @@ -12,24 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapInterpolationMode")] public enum WICBitmapInterpolationMode : int { - [Obsolete("Deprecated in favour of \"BitmapInterpolationModeNearestNeighbor\"")] - [NativeName("Name", "WICBitmapInterpolationModeNearestNeighbor")] - WicbitmapInterpolationModeNearestNeighbor = 0x0, - [Obsolete("Deprecated in favour of \"BitmapInterpolationModeLinear\"")] - [NativeName("Name", "WICBitmapInterpolationModeLinear")] - WicbitmapInterpolationModeLinear = 0x1, - [Obsolete("Deprecated in favour of \"BitmapInterpolationModeCubic\"")] - [NativeName("Name", "WICBitmapInterpolationModeCubic")] - WicbitmapInterpolationModeCubic = 0x2, - [Obsolete("Deprecated in favour of \"BitmapInterpolationModeFant\"")] - [NativeName("Name", "WICBitmapInterpolationModeFant")] - WicbitmapInterpolationModeFant = 0x3, - [Obsolete("Deprecated in favour of \"BitmapInterpolationModeHighQualityCubic\"")] - [NativeName("Name", "WICBitmapInterpolationModeHighQualityCubic")] - WicbitmapInterpolationModeHighQualityCubic = 0x4, - [Obsolete("Deprecated in favour of \"ItmapinterpolationmodeForceDword\"")] - [NativeName("Name", "WICBITMAPINTERPOLATIONMODE_FORCE_DWORD")] - WicbitmapinterpolationmodeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapInterpolationModeNearestNeighbor")] BitmapInterpolationModeNearestNeighbor = 0x0, [NativeName("Name", "WICBitmapInterpolationModeLinear")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs index 955d0c2c1c..131f070a2c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapLockFlags")] public enum WICBitmapLockFlags : int { - [Obsolete("Deprecated in favour of \"BitmapLockRead\"")] - [NativeName("Name", "WICBitmapLockRead")] - WicbitmapLockRead = 0x1, - [Obsolete("Deprecated in favour of \"BitmapLockWrite\"")] - [NativeName("Name", "WICBitmapLockWrite")] - WicbitmapLockWrite = 0x2, - [Obsolete("Deprecated in favour of \"ItmaplockflagsForceDword\"")] - [NativeName("Name", "WICBITMAPLOCKFLAGS_FORCE_DWORD")] - WicbitmaplockflagsForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapLockRead")] BitmapLockRead = 0x1, [NativeName("Name", "WICBitmapLockWrite")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs index ee3e9c1ef6..8bac80e60d 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs @@ -12,51 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapPaletteType")] public enum WICBitmapPaletteType : int { - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeCustom\"")] - [NativeName("Name", "WICBitmapPaletteTypeCustom")] - WicbitmapPaletteTypeCustom = 0x0, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeMedianCut\"")] - [NativeName("Name", "WICBitmapPaletteTypeMedianCut")] - WicbitmapPaletteTypeMedianCut = 0x1, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedBW\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedBW")] - WicbitmapPaletteTypeFixedBW = 0x2, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone8\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone8")] - WicbitmapPaletteTypeFixedHalftone8 = 0x3, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone27\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone27")] - WicbitmapPaletteTypeFixedHalftone27 = 0x4, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone64\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone64")] - WicbitmapPaletteTypeFixedHalftone64 = 0x5, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone125\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone125")] - WicbitmapPaletteTypeFixedHalftone125 = 0x6, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone216\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone216")] - WicbitmapPaletteTypeFixedHalftone216 = 0x7, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedWebPalette\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedWebPalette")] - WicbitmapPaletteTypeFixedWebPalette = 0x7, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone252\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone252")] - WicbitmapPaletteTypeFixedHalftone252 = 0x8, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedHalftone256\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedHalftone256")] - WicbitmapPaletteTypeFixedHalftone256 = 0x9, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedGray4\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedGray4")] - WicbitmapPaletteTypeFixedGray4 = 0xA, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedGray16\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedGray16")] - WicbitmapPaletteTypeFixedGray16 = 0xB, - [Obsolete("Deprecated in favour of \"BitmapPaletteTypeFixedGray256\"")] - [NativeName("Name", "WICBitmapPaletteTypeFixedGray256")] - WicbitmapPaletteTypeFixedGray256 = 0xC, - [Obsolete("Deprecated in favour of \"ItmappalettetypeForceDword\"")] - [NativeName("Name", "WICBITMAPPALETTETYPE_FORCE_DWORD")] - WicbitmappalettetypeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapPaletteTypeCustom")] BitmapPaletteTypeCustom = 0x0, [NativeName("Name", "WICBitmapPaletteTypeMedianCut")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs index 70c5800c28..c8e20fe461 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs @@ -13,27 +13,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICBitmapTransformOptions")] public enum WICBitmapTransformOptions : int { - [Obsolete("Deprecated in favour of \"BitmapTransformRotate0\"")] - [NativeName("Name", "WICBitmapTransformRotate0")] - WicbitmapTransformRotate0 = 0x0, - [Obsolete("Deprecated in favour of \"BitmapTransformRotate90\"")] - [NativeName("Name", "WICBitmapTransformRotate90")] - WicbitmapTransformRotate90 = 0x1, - [Obsolete("Deprecated in favour of \"BitmapTransformRotate180\"")] - [NativeName("Name", "WICBitmapTransformRotate180")] - WicbitmapTransformRotate180 = 0x2, - [Obsolete("Deprecated in favour of \"BitmapTransformRotate270\"")] - [NativeName("Name", "WICBitmapTransformRotate270")] - WicbitmapTransformRotate270 = 0x3, - [Obsolete("Deprecated in favour of \"BitmapTransformFlipHorizontal\"")] - [NativeName("Name", "WICBitmapTransformFlipHorizontal")] - WicbitmapTransformFlipHorizontal = 0x8, - [Obsolete("Deprecated in favour of \"BitmapTransformFlipVertical\"")] - [NativeName("Name", "WICBitmapTransformFlipVertical")] - WicbitmapTransformFlipVertical = 0x10, - [Obsolete("Deprecated in favour of \"ItmaptransformoptionsForceDword\"")] - [NativeName("Name", "WICBITMAPTRANSFORMOPTIONS_FORCE_DWORD")] - WicbitmaptransformoptionsForceDword = 0x7FFFFFFF, [NativeName("Name", "WICBitmapTransformRotate0")] BitmapTransformRotate0 = 0x0, [NativeName("Name", "WICBitmapTransformRotate90")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs index fd9d012f6e..8c828149ea 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICColorContextType")] public enum WICColorContextType : int { - [Obsolete("Deprecated in favour of \"Uninitialized\"")] - [NativeName("Name", "WICColorContextUninitialized")] - WiccolorContextUninitialized = 0x0, - [Obsolete("Deprecated in favour of \"Profile\"")] - [NativeName("Name", "WICColorContextProfile")] - WiccolorContextProfile = 0x1, - [Obsolete("Deprecated in favour of \"ExifColorSpace\"")] - [NativeName("Name", "WICColorContextExifColorSpace")] - WiccolorContextExifColorSpace = 0x2, [NativeName("Name", "WICColorContextUninitialized")] Uninitialized = 0x0, [NativeName("Name", "WICColorContextProfile")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs index 2e32a37820..994633d54a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs @@ -13,24 +13,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICComponentEnumerateOptions")] public enum WICComponentEnumerateOptions : int { - [Obsolete("Deprecated in favour of \"ComponentEnumerateDefault\"")] - [NativeName("Name", "WICComponentEnumerateDefault")] - WiccomponentEnumerateDefault = 0x0, - [Obsolete("Deprecated in favour of \"ComponentEnumerateRefresh\"")] - [NativeName("Name", "WICComponentEnumerateRefresh")] - WiccomponentEnumerateRefresh = 0x1, - [Obsolete("Deprecated in favour of \"ComponentEnumerateDisabled\"")] - [NativeName("Name", "WICComponentEnumerateDisabled")] - WiccomponentEnumerateDisabled = unchecked((int) 0xFFFFFFFF80000000), - [Obsolete("Deprecated in favour of \"ComponentEnumerateUnsigned\"")] - [NativeName("Name", "WICComponentEnumerateUnsigned")] - WiccomponentEnumerateUnsigned = 0x40000000, - [Obsolete("Deprecated in favour of \"ComponentEnumerateBuiltInOnly\"")] - [NativeName("Name", "WICComponentEnumerateBuiltInOnly")] - WiccomponentEnumerateBuiltInOnly = 0x20000000, - [Obsolete("Deprecated in favour of \"OmponentenumerateoptionsForceDword\"")] - [NativeName("Name", "WICCOMPONENTENUMERATEOPTIONS_FORCE_DWORD")] - WiccomponentenumerateoptionsForceDword = 0x7FFFFFFF, [NativeName("Name", "WICComponentEnumerateDefault")] ComponentEnumerateDefault = 0x0, [NativeName("Name", "WICComponentEnumerateRefresh")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs index 22447158fc..255b7dfcee 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs @@ -15,21 +15,6 @@ public enum WICComponentSigning : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"ComponentSigned\"")] - [NativeName("Name", "WICComponentSigned")] - WiccomponentSigned = 0x1, - [Obsolete("Deprecated in favour of \"ComponentUnsigned\"")] - [NativeName("Name", "WICComponentUnsigned")] - WiccomponentUnsigned = 0x2, - [Obsolete("Deprecated in favour of \"ComponentSafe\"")] - [NativeName("Name", "WICComponentSafe")] - WiccomponentSafe = 0x4, - [Obsolete("Deprecated in favour of \"ComponentDisabled\"")] - [NativeName("Name", "WICComponentDisabled")] - WiccomponentDisabled = unchecked((int) 0xFFFFFFFF80000000), - [Obsolete("Deprecated in favour of \"OmponentsigningForceDword\"")] - [NativeName("Name", "WICCOMPONENTSIGNING_FORCE_DWORD")] - WiccomponentsigningForceDword = 0x7FFFFFFF, [NativeName("Name", "WICComponentSigned")] ComponentSigned = 0x1, [NativeName("Name", "WICComponentUnsigned")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs index 681a231711..09b2fa0cde 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs @@ -15,30 +15,6 @@ public enum WICComponentType : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"Decoder\"")] - [NativeName("Name", "WICDecoder")] - Wicdecoder = 0x1, - [Obsolete("Deprecated in favour of \"Encoder\"")] - [NativeName("Name", "WICEncoder")] - Wicencoder = 0x2, - [Obsolete("Deprecated in favour of \"PixelFormatConverter\"")] - [NativeName("Name", "WICPixelFormatConverter")] - WicpixelFormatConverter = 0x4, - [Obsolete("Deprecated in favour of \"MetadataReader\"")] - [NativeName("Name", "WICMetadataReader")] - WicmetadataReader = 0x8, - [Obsolete("Deprecated in favour of \"MetadataWriter\"")] - [NativeName("Name", "WICMetadataWriter")] - WicmetadataWriter = 0x10, - [Obsolete("Deprecated in favour of \"PixelFormat\"")] - [NativeName("Name", "WICPixelFormat")] - WicpixelFormat = 0x20, - [Obsolete("Deprecated in favour of \"AllComponents\"")] - [NativeName("Name", "WICAllComponents")] - WicallComponents = 0x3F, - [Obsolete("Deprecated in favour of \"OmponenttypeForceDword\"")] - [NativeName("Name", "WICCOMPONENTTYPE_FORCE_DWORD")] - WiccomponenttypeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICDecoder")] Decoder = 0x1, [NativeName("Name", "WICEncoder")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs index 066749e20c..a18ca88dff 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs @@ -12,24 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICDdsAlphaMode")] public enum WICDdsAlphaMode : int { - [Obsolete("Deprecated in favour of \"DdsAlphaModeUnknown\"")] - [NativeName("Name", "WICDdsAlphaModeUnknown")] - WicddsAlphaModeUnknown = 0x0, - [Obsolete("Deprecated in favour of \"DdsAlphaModeStraight\"")] - [NativeName("Name", "WICDdsAlphaModeStraight")] - WicddsAlphaModeStraight = 0x1, - [Obsolete("Deprecated in favour of \"DdsAlphaModePremultiplied\"")] - [NativeName("Name", "WICDdsAlphaModePremultiplied")] - WicddsAlphaModePremultiplied = 0x2, - [Obsolete("Deprecated in favour of \"DdsAlphaModeOpaque\"")] - [NativeName("Name", "WICDdsAlphaModeOpaque")] - WicddsAlphaModeOpaque = 0x3, - [Obsolete("Deprecated in favour of \"DdsAlphaModeCustom\"")] - [NativeName("Name", "WICDdsAlphaModeCustom")] - WicddsAlphaModeCustom = 0x4, - [Obsolete("Deprecated in favour of \"DsalphamodeForceDword\"")] - [NativeName("Name", "WICDDSALPHAMODE_FORCE_DWORD")] - WicddsalphamodeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICDdsAlphaModeUnknown")] DdsAlphaModeUnknown = 0x0, [NativeName("Name", "WICDdsAlphaModeStraight")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs index 8b6f142954..b43020c592 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs @@ -12,21 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICDdsDimension")] public enum WICDdsDimension : int { - [Obsolete("Deprecated in favour of \"DdsTexture1D\"")] - [NativeName("Name", "WICDdsTexture1D")] - WicddsTexture1D = 0x0, - [Obsolete("Deprecated in favour of \"DdsTexture2D\"")] - [NativeName("Name", "WICDdsTexture2D")] - WicddsTexture2D = 0x1, - [Obsolete("Deprecated in favour of \"DdsTexture3D\"")] - [NativeName("Name", "WICDdsTexture3D")] - WicddsTexture3D = 0x2, - [Obsolete("Deprecated in favour of \"DdsTextureCube\"")] - [NativeName("Name", "WICDdsTextureCube")] - WicddsTextureCube = 0x3, - [Obsolete("Deprecated in favour of \"DstextureForceDword\"")] - [NativeName("Name", "WICDDSTEXTURE_FORCE_DWORD")] - WicddstextureForceDword = 0x7FFFFFFF, [NativeName("Name", "WICDdsTexture1D")] DdsTexture1D = 0x0, [NativeName("Name", "WICDdsTexture2D")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs index 49b5fabe22..ada1b50742 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICDecodeOptions")] public enum WICDecodeOptions : int { - [Obsolete("Deprecated in favour of \"DecodeMetadataCacheOnDemand\"")] - [NativeName("Name", "WICDecodeMetadataCacheOnDemand")] - WicdecodeMetadataCacheOnDemand = 0x0, - [Obsolete("Deprecated in favour of \"DecodeMetadataCacheOnLoad\"")] - [NativeName("Name", "WICDecodeMetadataCacheOnLoad")] - WicdecodeMetadataCacheOnLoad = 0x1, - [Obsolete("Deprecated in favour of \"EtadatacacheoptionForceDword\"")] - [NativeName("Name", "WICMETADATACACHEOPTION_FORCE_DWORD")] - WicmetadatacacheoptionForceDword = 0x7FFFFFFF, [NativeName("Name", "WICDecodeMetadataCacheOnDemand")] DecodeMetadataCacheOnDemand = 0x0, [NativeName("Name", "WICDecodeMetadataCacheOnLoad")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs index f557063fd9..f2c40d3fa7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICGifApplicationExtensionProperties")] public enum WICGifApplicationExtensionProperties : int { - [Obsolete("Deprecated in favour of \"Application\"")] - [NativeName("Name", "WICGifApplicationExtensionApplication")] - WicgifApplicationExtensionApplication = 0x1, - [Obsolete("Deprecated in favour of \"Data\"")] - [NativeName("Name", "WICGifApplicationExtensionData")] - WicgifApplicationExtensionData = 0x2, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICGifApplicationExtensionProperties_FORCE_DWORD")] - WicgifApplicationExtensionPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICGifApplicationExtensionApplication")] Application = 0x1, [NativeName("Name", "WICGifApplicationExtensionData")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs index d832031db4..7afbf8ac63 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICGifCommentExtensionProperties")] public enum WICGifCommentExtensionProperties : int { - [Obsolete("Deprecated in favour of \"Text\"")] - [NativeName("Name", "WICGifCommentExtensionText")] - WicgifCommentExtensionText = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICGifCommentExtensionProperties_FORCE_DWORD")] - WicgifCommentExtensionPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICGifCommentExtensionText")] Text = 0x1, [NativeName("Name", "WICGifCommentExtensionProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs index 320f4ec490..1b5c4cbb0c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs @@ -12,24 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICGifGraphicControlExtensionProperties")] public enum WICGifGraphicControlExtensionProperties : int { - [Obsolete("Deprecated in favour of \"Disposal\"")] - [NativeName("Name", "WICGifGraphicControlExtensionDisposal")] - WicgifGraphicControlExtensionDisposal = 0x1, - [Obsolete("Deprecated in favour of \"UserInputFlag\"")] - [NativeName("Name", "WICGifGraphicControlExtensionUserInputFlag")] - WicgifGraphicControlExtensionUserInputFlag = 0x2, - [Obsolete("Deprecated in favour of \"TransparencyFlag\"")] - [NativeName("Name", "WICGifGraphicControlExtensionTransparencyFlag")] - WicgifGraphicControlExtensionTransparencyFlag = 0x3, - [Obsolete("Deprecated in favour of \"Delay\"")] - [NativeName("Name", "WICGifGraphicControlExtensionDelay")] - WicgifGraphicControlExtensionDelay = 0x4, - [Obsolete("Deprecated in favour of \"TransparentColorIndex\"")] - [NativeName("Name", "WICGifGraphicControlExtensionTransparentColorIndex")] - WicgifGraphicControlExtensionTransparentColorIndex = 0x5, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICGifGraphicControlExtensionProperties_FORCE_DWORD")] - WicgifGraphicControlExtensionPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICGifGraphicControlExtensionDisposal")] Disposal = 0x1, [NativeName("Name", "WICGifGraphicControlExtensionUserInputFlag")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs index 0ccae64a82..92b12f3123 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs @@ -12,33 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICGifImageDescriptorProperties")] public enum WICGifImageDescriptorProperties : int { - [Obsolete("Deprecated in favour of \"Left\"")] - [NativeName("Name", "WICGifImageDescriptorLeft")] - WicgifImageDescriptorLeft = 0x1, - [Obsolete("Deprecated in favour of \"Top\"")] - [NativeName("Name", "WICGifImageDescriptorTop")] - WicgifImageDescriptorTop = 0x2, - [Obsolete("Deprecated in favour of \"Width\"")] - [NativeName("Name", "WICGifImageDescriptorWidth")] - WicgifImageDescriptorWidth = 0x3, - [Obsolete("Deprecated in favour of \"Height\"")] - [NativeName("Name", "WICGifImageDescriptorHeight")] - WicgifImageDescriptorHeight = 0x4, - [Obsolete("Deprecated in favour of \"LocalColorTableFlag\"")] - [NativeName("Name", "WICGifImageDescriptorLocalColorTableFlag")] - WicgifImageDescriptorLocalColorTableFlag = 0x5, - [Obsolete("Deprecated in favour of \"InterlaceFlag\"")] - [NativeName("Name", "WICGifImageDescriptorInterlaceFlag")] - WicgifImageDescriptorInterlaceFlag = 0x6, - [Obsolete("Deprecated in favour of \"SortFlag\"")] - [NativeName("Name", "WICGifImageDescriptorSortFlag")] - WicgifImageDescriptorSortFlag = 0x7, - [Obsolete("Deprecated in favour of \"LocalColorTableSize\"")] - [NativeName("Name", "WICGifImageDescriptorLocalColorTableSize")] - WicgifImageDescriptorLocalColorTableSize = 0x8, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICGifImageDescriptorProperties_FORCE_DWORD")] - WicgifImageDescriptorPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICGifImageDescriptorLeft")] Left = 0x1, [NativeName("Name", "WICGifImageDescriptorTop")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs index 0536d27490..6648796638 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs @@ -12,36 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICGifLogicalScreenDescriptorProperties")] public enum WICGifLogicalScreenDescriptorProperties : int { - [Obsolete("Deprecated in favour of \"Signature\"")] - [NativeName("Name", "WICGifLogicalScreenSignature")] - WicgifLogicalScreenSignature = 0x1, - [Obsolete("Deprecated in favour of \"DescriptorWidth\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorWidth")] - WicgifLogicalScreenDescriptorWidth = 0x2, - [Obsolete("Deprecated in favour of \"DescriptorHeight\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorHeight")] - WicgifLogicalScreenDescriptorHeight = 0x3, - [Obsolete("Deprecated in favour of \"DescriptorGlobalColorTableFlag\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorGlobalColorTableFlag")] - WicgifLogicalScreenDescriptorGlobalColorTableFlag = 0x4, - [Obsolete("Deprecated in favour of \"DescriptorColorResolution\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorColorResolution")] - WicgifLogicalScreenDescriptorColorResolution = 0x5, - [Obsolete("Deprecated in favour of \"DescriptorSortFlag\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorSortFlag")] - WicgifLogicalScreenDescriptorSortFlag = 0x6, - [Obsolete("Deprecated in favour of \"DescriptorGlobalColorTableSize\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorGlobalColorTableSize")] - WicgifLogicalScreenDescriptorGlobalColorTableSize = 0x7, - [Obsolete("Deprecated in favour of \"DescriptorBackgroundColorIndex\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorBackgroundColorIndex")] - WicgifLogicalScreenDescriptorBackgroundColorIndex = 0x8, - [Obsolete("Deprecated in favour of \"DescriptorPixelAspectRatio\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorPixelAspectRatio")] - WicgifLogicalScreenDescriptorPixelAspectRatio = 0x9, - [Obsolete("Deprecated in favour of \"DescriptorPropertiesForceDword\"")] - [NativeName("Name", "WICGifLogicalScreenDescriptorProperties_FORCE_DWORD")] - WicgifLogicalScreenDescriptorPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICGifLogicalScreenSignature")] Signature = 0x1, [NativeName("Name", "WICGifLogicalScreenDescriptorWidth")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs index 14198d135b..35fe37e0eb 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs @@ -12,24 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICHeifHdrProperties")] public enum WICHeifHdrProperties : int { - [Obsolete("Deprecated in favour of \"MaximumLuminanceLevel\"")] - [NativeName("Name", "WICHeifHdrMaximumLuminanceLevel")] - WicheifHdrMaximumLuminanceLevel = 0x1, - [Obsolete("Deprecated in favour of \"MaximumFrameAverageLuminanceLevel\"")] - [NativeName("Name", "WICHeifHdrMaximumFrameAverageLuminanceLevel")] - WicheifHdrMaximumFrameAverageLuminanceLevel = 0x2, - [Obsolete("Deprecated in favour of \"MinimumMasteringDisplayLuminanceLevel\"")] - [NativeName("Name", "WICHeifHdrMinimumMasteringDisplayLuminanceLevel")] - WicheifHdrMinimumMasteringDisplayLuminanceLevel = 0x3, - [Obsolete("Deprecated in favour of \"MaximumMasteringDisplayLuminanceLevel\"")] - [NativeName("Name", "WICHeifHdrMaximumMasteringDisplayLuminanceLevel")] - WicheifHdrMaximumMasteringDisplayLuminanceLevel = 0x4, - [Obsolete("Deprecated in favour of \"CustomVideoPrimaries\"")] - [NativeName("Name", "WICHeifHdrCustomVideoPrimaries")] - WicheifHdrCustomVideoPrimaries = 0x5, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICHeifHdrProperties_FORCE_DWORD")] - WicheifHdrPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICHeifHdrMaximumLuminanceLevel")] MaximumLuminanceLevel = 0x1, [NativeName("Name", "WICHeifHdrMaximumFrameAverageLuminanceLevel")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs index e9cb26e2e4..1925b982e7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICHeifProperties")] public enum WICHeifProperties : int { - [Obsolete("Deprecated in favour of \"Orientation\"")] - [NativeName("Name", "WICHeifOrientation")] - WicheifOrientation = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICHeifProperties_FORCE_DWORD")] - WicheifPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICHeifOrientation")] Orientation = 0x1, [NativeName("Name", "WICHeifProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs index 4e46fde898..ae39087034 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegChrominanceProperties")] public enum WICJpegChrominanceProperties : int { - [Obsolete("Deprecated in favour of \"Table\"")] - [NativeName("Name", "WICJpegChrominanceTable")] - WicjpegChrominanceTable = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICJpegChrominanceProperties_FORCE_DWORD")] - WicjpegChrominancePropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegChrominanceTable")] Table = 0x1, [NativeName("Name", "WICJpegChrominanceProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs index d4f7421eea..e481f53547 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegCommentProperties")] public enum WICJpegCommentProperties : int { - [Obsolete("Deprecated in favour of \"Text\"")] - [NativeName("Name", "WICJpegCommentText")] - WicjpegCommentText = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICJpegCommentProperties_FORCE_DWORD")] - WicjpegCommentPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegCommentText")] Text = 0x1, [NativeName("Name", "WICJpegCommentProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs index 1f632d9772..fe66fd0fc9 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegIndexingOptions")] public enum WICJpegIndexingOptions : int { - [Obsolete("Deprecated in favour of \"GenerateOnDemand\"")] - [NativeName("Name", "WICJpegIndexingOptionsGenerateOnDemand")] - WicjpegIndexingOptionsGenerateOnDemand = 0x0, - [Obsolete("Deprecated in favour of \"GenerateOnLoad\"")] - [NativeName("Name", "WICJpegIndexingOptionsGenerateOnLoad")] - WicjpegIndexingOptionsGenerateOnLoad = 0x1, - [Obsolete("Deprecated in favour of \"ForceDword\"")] - [NativeName("Name", "WICJpegIndexingOptions_FORCE_DWORD")] - WicjpegIndexingOptionsForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegIndexingOptionsGenerateOnDemand")] GenerateOnDemand = 0x0, [NativeName("Name", "WICJpegIndexingOptionsGenerateOnLoad")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs index 0672bf66a3..a4105331cf 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegLuminanceProperties")] public enum WICJpegLuminanceProperties : int { - [Obsolete("Deprecated in favour of \"Table\"")] - [NativeName("Name", "WICJpegLuminanceTable")] - WicjpegLuminanceTable = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICJpegLuminanceProperties_FORCE_DWORD")] - WicjpegLuminancePropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegLuminanceTable")] Table = 0x1, [NativeName("Name", "WICJpegLuminanceProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs index 7adeb9e780..e1ce5b539e 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegScanType")] public enum WICJpegScanType : int { - [Obsolete("Deprecated in favour of \"Interleaved\"")] - [NativeName("Name", "WICJpegScanTypeInterleaved")] - WicjpegScanTypeInterleaved = 0x0, - [Obsolete("Deprecated in favour of \"PlanarComponents\"")] - [NativeName("Name", "WICJpegScanTypePlanarComponents")] - WicjpegScanTypePlanarComponents = 0x1, - [Obsolete("Deprecated in favour of \"Progressive\"")] - [NativeName("Name", "WICJpegScanTypeProgressive")] - WicjpegScanTypeProgressive = 0x2, - [Obsolete("Deprecated in favour of \"ForceDword\"")] - [NativeName("Name", "WICJpegScanType_FORCE_DWORD")] - WicjpegScanTypeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegScanTypeInterleaved")] Interleaved = 0x0, [NativeName("Name", "WICJpegScanTypePlanarComponents")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs index 30e427edce..45dc3837b1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegTransferMatrix")] public enum WICJpegTransferMatrix : int { - [Obsolete("Deprecated in favour of \"Identity\"")] - [NativeName("Name", "WICJpegTransferMatrixIdentity")] - WicjpegTransferMatrixIdentity = 0x0, - [Obsolete("Deprecated in favour of \"BT601\"")] - [NativeName("Name", "WICJpegTransferMatrixBT601")] - WicjpegTransferMatrixBT601 = 0x1, - [Obsolete("Deprecated in favour of \"ForceDword\"")] - [NativeName("Name", "WICJpegTransferMatrix_FORCE_DWORD")] - WicjpegTransferMatrixForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegTransferMatrixIdentity")] Identity = 0x0, [NativeName("Name", "WICJpegTransferMatrixBT601")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs index ae46176e51..b8ecc553da 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs @@ -12,24 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICJpegYCrCbSubsamplingOption")] public enum WICJpegYCrCbSubsamplingOption : int { - [Obsolete("Deprecated in favour of \"JpegYCrCbSubsamplingDefault\"")] - [NativeName("Name", "WICJpegYCrCbSubsamplingDefault")] - WicjpegYCrCbSubsamplingDefault = 0x0, - [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling420\"")] - [NativeName("Name", "WICJpegYCrCbSubsampling420")] - WicjpegYCrCbSubsampling420 = 0x1, - [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling422\"")] - [NativeName("Name", "WICJpegYCrCbSubsampling422")] - WicjpegYCrCbSubsampling422 = 0x2, - [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling444\"")] - [NativeName("Name", "WICJpegYCrCbSubsampling444")] - WicjpegYCrCbSubsampling444 = 0x3, - [Obsolete("Deprecated in favour of \"JpegYCrCbSubsampling440\"")] - [NativeName("Name", "WICJpegYCrCbSubsampling440")] - WicjpegYCrCbSubsampling440 = 0x4, - [Obsolete("Deprecated in favour of \"PegycrcbsubsamplingForceDword\"")] - [NativeName("Name", "WICJPEGYCRCBSUBSAMPLING_FORCE_DWORD")] - WicjpegycrcbsubsamplingForceDword = 0x7FFFFFFF, [NativeName("Name", "WICJpegYCrCbSubsamplingDefault")] JpegYCrCbSubsamplingDefault = 0x0, [NativeName("Name", "WICJpegYCrCbSubsampling420")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs index 5981508d1f..200eb8e5a0 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICMetadataCreationOptions")] public enum WICMetadataCreationOptions : int { - [Obsolete("Deprecated in favour of \"Default\"")] - [NativeName("Name", "WICMetadataCreationDefault")] - WicmetadataCreationDefault = 0x0, - [Obsolete("Deprecated in favour of \"AllowUnknown\"")] - [NativeName("Name", "WICMetadataCreationAllowUnknown")] - WicmetadataCreationAllowUnknown = 0x0, - [Obsolete("Deprecated in favour of \"FailUnknown\"")] - [NativeName("Name", "WICMetadataCreationFailUnknown")] - WicmetadataCreationFailUnknown = 0x10000, - [Obsolete("Deprecated in favour of \"Mask\"")] - [NativeName("Name", "WICMetadataCreationMask")] - WicmetadataCreationMask = unchecked((int) 0xFFFFFFFFFFFF0000), [NativeName("Name", "WICMetadataCreationDefault")] Default = 0x0, [NativeName("Name", "WICMetadataCreationAllowUnknown")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs index bc3262a44c..eb19f5a2ae 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs @@ -15,42 +15,6 @@ public enum WICNamedWhitePoint : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"WhitePointDefault\"")] - [NativeName("Name", "WICWhitePointDefault")] - WicwhitePointDefault = 0x1, - [Obsolete("Deprecated in favour of \"WhitePointDaylight\"")] - [NativeName("Name", "WICWhitePointDaylight")] - WicwhitePointDaylight = 0x2, - [Obsolete("Deprecated in favour of \"WhitePointCloudy\"")] - [NativeName("Name", "WICWhitePointCloudy")] - WicwhitePointCloudy = 0x4, - [Obsolete("Deprecated in favour of \"WhitePointShade\"")] - [NativeName("Name", "WICWhitePointShade")] - WicwhitePointShade = 0x8, - [Obsolete("Deprecated in favour of \"WhitePointTungsten\"")] - [NativeName("Name", "WICWhitePointTungsten")] - WicwhitePointTungsten = 0x10, - [Obsolete("Deprecated in favour of \"WhitePointFluorescent\"")] - [NativeName("Name", "WICWhitePointFluorescent")] - WicwhitePointFluorescent = 0x20, - [Obsolete("Deprecated in favour of \"WhitePointFlash\"")] - [NativeName("Name", "WICWhitePointFlash")] - WicwhitePointFlash = 0x40, - [Obsolete("Deprecated in favour of \"WhitePointUnderwater\"")] - [NativeName("Name", "WICWhitePointUnderwater")] - WicwhitePointUnderwater = 0x80, - [Obsolete("Deprecated in favour of \"WhitePointCustom\"")] - [NativeName("Name", "WICWhitePointCustom")] - WicwhitePointCustom = 0x100, - [Obsolete("Deprecated in favour of \"WhitePointAutoWhiteBalance\"")] - [NativeName("Name", "WICWhitePointAutoWhiteBalance")] - WicwhitePointAutoWhiteBalance = 0x200, - [Obsolete("Deprecated in favour of \"WhitePointAsShot\"")] - [NativeName("Name", "WICWhitePointAsShot")] - WicwhitePointAsShot = 0x1, - [Obsolete("Deprecated in favour of \"AmedwhitepointForceDword\"")] - [NativeName("Name", "WICNAMEDWHITEPOINT_FORCE_DWORD")] - WicnamedwhitepointForceDword = 0x7FFFFFFF, [NativeName("Name", "WICWhitePointDefault")] WhitePointDefault = 0x1, [NativeName("Name", "WICWhitePointDaylight")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs index 3cfaa00cb2..88228f9354 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs @@ -13,27 +13,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPersistOptions")] public enum WICPersistOptions : int { - [Obsolete("Deprecated in favour of \"Default\"")] - [NativeName("Name", "WICPersistOptionDefault")] - WicpersistOptionDefault = 0x0, - [Obsolete("Deprecated in favour of \"LittleEndian\"")] - [NativeName("Name", "WICPersistOptionLittleEndian")] - WicpersistOptionLittleEndian = 0x0, - [Obsolete("Deprecated in favour of \"BigEndian\"")] - [NativeName("Name", "WICPersistOptionBigEndian")] - WicpersistOptionBigEndian = 0x1, - [Obsolete("Deprecated in favour of \"StrictFormat\"")] - [NativeName("Name", "WICPersistOptionStrictFormat")] - WicpersistOptionStrictFormat = 0x2, - [Obsolete("Deprecated in favour of \"NoCacheStream\"")] - [NativeName("Name", "WICPersistOptionNoCacheStream")] - WicpersistOptionNoCacheStream = 0x4, - [Obsolete("Deprecated in favour of \"PreferUtf8\"")] - [NativeName("Name", "WICPersistOptionPreferUTF8")] - WicpersistOptionPreferUtf8 = 0x8, - [Obsolete("Deprecated in favour of \"Mask\"")] - [NativeName("Name", "WICPersistOptionMask")] - WicpersistOptionMask = 0xFFFF, [NativeName("Name", "WICPersistOptionDefault")] Default = 0x0, [NativeName("Name", "WICPersistOptionLittleEndian")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs index c78420c310..893886f0e7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs @@ -12,27 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPixelFormatNumericRepresentation")] public enum WICPixelFormatNumericRepresentation : int { - [Obsolete("Deprecated in favour of \"Unspecified\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentationUnspecified")] - WicpixelFormatNumericRepresentationUnspecified = 0x0, - [Obsolete("Deprecated in favour of \"Indexed\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentationIndexed")] - WicpixelFormatNumericRepresentationIndexed = 0x1, - [Obsolete("Deprecated in favour of \"UnsignedInteger\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentationUnsignedInteger")] - WicpixelFormatNumericRepresentationUnsignedInteger = 0x2, - [Obsolete("Deprecated in favour of \"SignedInteger\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentationSignedInteger")] - WicpixelFormatNumericRepresentationSignedInteger = 0x3, - [Obsolete("Deprecated in favour of \"Fixed\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentationFixed")] - WicpixelFormatNumericRepresentationFixed = 0x4, - [Obsolete("Deprecated in favour of \"Float\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentationFloat")] - WicpixelFormatNumericRepresentationFloat = 0x5, - [Obsolete("Deprecated in favour of \"ForceDword\"")] - [NativeName("Name", "WICPixelFormatNumericRepresentation_FORCE_DWORD")] - WicpixelFormatNumericRepresentationForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPixelFormatNumericRepresentationUnspecified")] Unspecified = 0x0, [NativeName("Name", "WICPixelFormatNumericRepresentationIndexed")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs index 916eda5a98..6f6ce7a849 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPlanarOptions")] public enum WICPlanarOptions : int { - [Obsolete("Deprecated in favour of \"PlanarOptionsDefault\"")] - [NativeName("Name", "WICPlanarOptionsDefault")] - WicplanarOptionsDefault = 0x0, - [Obsolete("Deprecated in favour of \"PlanarOptionsPreserveSubsampling\"")] - [NativeName("Name", "WICPlanarOptionsPreserveSubsampling")] - WicplanarOptionsPreserveSubsampling = 0x1, - [Obsolete("Deprecated in favour of \"LanaroptionsForceDword\"")] - [NativeName("Name", "WICPLANAROPTIONS_FORCE_DWORD")] - WicplanaroptionsForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPlanarOptionsDefault")] PlanarOptionsDefault = 0x0, [NativeName("Name", "WICPlanarOptionsPreserveSubsampling")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs index ae92414a45..edb2a1a1b8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngBkgdProperties")] public enum WICPngBkgdProperties : int { - [Obsolete("Deprecated in favour of \"BackgroundColor\"")] - [NativeName("Name", "WICPngBkgdBackgroundColor")] - WicpngBkgdBackgroundColor = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngBkgdProperties_FORCE_DWORD")] - WicpngBkgdPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngBkgdBackgroundColor")] BackgroundColor = 0x1, [NativeName("Name", "WICPngBkgdProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs index f864b781d2..33f9429bb7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs @@ -12,33 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngChrmProperties")] public enum WICPngChrmProperties : int { - [Obsolete("Deprecated in favour of \"WhitePointX\"")] - [NativeName("Name", "WICPngChrmWhitePointX")] - WicpngChrmWhitePointX = 0x1, - [Obsolete("Deprecated in favour of \"WhitePointY\"")] - [NativeName("Name", "WICPngChrmWhitePointY")] - WicpngChrmWhitePointY = 0x2, - [Obsolete("Deprecated in favour of \"RedX\"")] - [NativeName("Name", "WICPngChrmRedX")] - WicpngChrmRedX = 0x3, - [Obsolete("Deprecated in favour of \"RedY\"")] - [NativeName("Name", "WICPngChrmRedY")] - WicpngChrmRedY = 0x4, - [Obsolete("Deprecated in favour of \"GreenX\"")] - [NativeName("Name", "WICPngChrmGreenX")] - WicpngChrmGreenX = 0x5, - [Obsolete("Deprecated in favour of \"GreenY\"")] - [NativeName("Name", "WICPngChrmGreenY")] - WicpngChrmGreenY = 0x6, - [Obsolete("Deprecated in favour of \"BlueX\"")] - [NativeName("Name", "WICPngChrmBlueX")] - WicpngChrmBlueX = 0x7, - [Obsolete("Deprecated in favour of \"BlueY\"")] - [NativeName("Name", "WICPngChrmBlueY")] - WicpngChrmBlueY = 0x8, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngChrmProperties_FORCE_DWORD")] - WicpngChrmPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngChrmWhitePointX")] WhitePointX = 0x1, [NativeName("Name", "WICPngChrmWhitePointY")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs index ba4a53b5d7..99bb605ca2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs @@ -12,30 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngFilterOption")] public enum WICPngFilterOption : int { - [Obsolete("Deprecated in favour of \"PngFilterUnspecified\"")] - [NativeName("Name", "WICPngFilterUnspecified")] - WicpngFilterUnspecified = 0x0, - [Obsolete("Deprecated in favour of \"PngFilterNone\"")] - [NativeName("Name", "WICPngFilterNone")] - WicpngFilterNone = 0x1, - [Obsolete("Deprecated in favour of \"PngFilterSub\"")] - [NativeName("Name", "WICPngFilterSub")] - WicpngFilterSub = 0x2, - [Obsolete("Deprecated in favour of \"PngFilterUp\"")] - [NativeName("Name", "WICPngFilterUp")] - WicpngFilterUp = 0x3, - [Obsolete("Deprecated in favour of \"PngFilterAverage\"")] - [NativeName("Name", "WICPngFilterAverage")] - WicpngFilterAverage = 0x4, - [Obsolete("Deprecated in favour of \"PngFilterPaeth\"")] - [NativeName("Name", "WICPngFilterPaeth")] - WicpngFilterPaeth = 0x5, - [Obsolete("Deprecated in favour of \"PngFilterAdaptive\"")] - [NativeName("Name", "WICPngFilterAdaptive")] - WicpngFilterAdaptive = 0x6, - [Obsolete("Deprecated in favour of \"NgfilteroptionForceDword\"")] - [NativeName("Name", "WICPNGFILTEROPTION_FORCE_DWORD")] - WicpngfilteroptionForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngFilterUnspecified")] PngFilterUnspecified = 0x0, [NativeName("Name", "WICPngFilterNone")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs index d3840f0ac6..1488b854c9 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngGamaProperties")] public enum WICPngGamaProperties : int { - [Obsolete("Deprecated in favour of \"Gamma\"")] - [NativeName("Name", "WICPngGamaGamma")] - WicpngGamaGamma = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngGamaProperties_FORCE_DWORD")] - WicpngGamaPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngGamaGamma")] Gamma = 0x1, [NativeName("Name", "WICPngGamaProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs index c0a4fba3b5..1122c57fc8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngHistProperties")] public enum WICPngHistProperties : int { - [Obsolete("Deprecated in favour of \"Frequencies\"")] - [NativeName("Name", "WICPngHistFrequencies")] - WicpngHistFrequencies = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngHistProperties_FORCE_DWORD")] - WicpngHistPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngHistFrequencies")] Frequencies = 0x1, [NativeName("Name", "WICPngHistProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs index bec8337980..dfecc0b8dc 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs @@ -12,15 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngIccpProperties")] public enum WICPngIccpProperties : int { - [Obsolete("Deprecated in favour of \"ProfileName\"")] - [NativeName("Name", "WICPngIccpProfileName")] - WicpngIccpProfileName = 0x1, - [Obsolete("Deprecated in favour of \"ProfileData\"")] - [NativeName("Name", "WICPngIccpProfileData")] - WicpngIccpProfileData = 0x2, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngIccpProperties_FORCE_DWORD")] - WicpngIccpPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngIccpProfileName")] ProfileName = 0x1, [NativeName("Name", "WICPngIccpProfileData")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs index df1158be37..4948dea424 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs @@ -12,24 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngItxtProperties")] public enum WICPngItxtProperties : int { - [Obsolete("Deprecated in favour of \"Keyword\"")] - [NativeName("Name", "WICPngItxtKeyword")] - WicpngItxtKeyword = 0x1, - [Obsolete("Deprecated in favour of \"CompressionFlag\"")] - [NativeName("Name", "WICPngItxtCompressionFlag")] - WicpngItxtCompressionFlag = 0x2, - [Obsolete("Deprecated in favour of \"LanguageTag\"")] - [NativeName("Name", "WICPngItxtLanguageTag")] - WicpngItxtLanguageTag = 0x3, - [Obsolete("Deprecated in favour of \"TranslatedKeyword\"")] - [NativeName("Name", "WICPngItxtTranslatedKeyword")] - WicpngItxtTranslatedKeyword = 0x4, - [Obsolete("Deprecated in favour of \"Text\"")] - [NativeName("Name", "WICPngItxtText")] - WicpngItxtText = 0x5, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngItxtProperties_FORCE_DWORD")] - WicpngItxtPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngItxtKeyword")] Keyword = 0x1, [NativeName("Name", "WICPngItxtCompressionFlag")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs index d33685ae63..c252cd33b5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngSrgbProperties")] public enum WICPngSrgbProperties : int { - [Obsolete("Deprecated in favour of \"RenderingIntent\"")] - [NativeName("Name", "WICPngSrgbRenderingIntent")] - WicpngSrgbRenderingIntent = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngSrgbProperties_FORCE_DWORD")] - WicpngSrgbPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngSrgbRenderingIntent")] RenderingIntent = 0x1, [NativeName("Name", "WICPngSrgbProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs index ced073cb70..88177c8d26 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs @@ -12,27 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICPngTimeProperties")] public enum WICPngTimeProperties : int { - [Obsolete("Deprecated in favour of \"Year\"")] - [NativeName("Name", "WICPngTimeYear")] - WicpngTimeYear = 0x1, - [Obsolete("Deprecated in favour of \"Month\"")] - [NativeName("Name", "WICPngTimeMonth")] - WicpngTimeMonth = 0x2, - [Obsolete("Deprecated in favour of \"Day\"")] - [NativeName("Name", "WICPngTimeDay")] - WicpngTimeDay = 0x3, - [Obsolete("Deprecated in favour of \"Hour\"")] - [NativeName("Name", "WICPngTimeHour")] - WicpngTimeHour = 0x4, - [Obsolete("Deprecated in favour of \"Minute\"")] - [NativeName("Name", "WICPngTimeMinute")] - WicpngTimeMinute = 0x5, - [Obsolete("Deprecated in favour of \"Second\"")] - [NativeName("Name", "WICPngTimeSecond")] - WicpngTimeSecond = 0x6, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICPngTimeProperties_FORCE_DWORD")] - WicpngTimePropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICPngTimeYear")] Year = 0x1, [NativeName("Name", "WICPngTimeMonth")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs index 137082765c..063ce4cf0c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs @@ -15,21 +15,6 @@ public enum WICProgressNotification : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"ProgressNotificationBegin\"")] - [NativeName("Name", "WICProgressNotificationBegin")] - WicprogressNotificationBegin = 0x10000, - [Obsolete("Deprecated in favour of \"ProgressNotificationEnd\"")] - [NativeName("Name", "WICProgressNotificationEnd")] - WicprogressNotificationEnd = 0x20000, - [Obsolete("Deprecated in favour of \"ProgressNotificationFrequent\"")] - [NativeName("Name", "WICProgressNotificationFrequent")] - WicprogressNotificationFrequent = 0x40000, - [Obsolete("Deprecated in favour of \"ProgressNotificationAll\"")] - [NativeName("Name", "WICProgressNotificationAll")] - WicprogressNotificationAll = unchecked((int) 0xFFFFFFFFFFFF0000), - [Obsolete("Deprecated in favour of \"RogressnotificationForceDword\"")] - [NativeName("Name", "WICPROGRESSNOTIFICATION_FORCE_DWORD")] - WicprogressnotificationForceDword = 0x7FFFFFFF, [NativeName("Name", "WICProgressNotificationBegin")] ProgressNotificationBegin = 0x10000, [NativeName("Name", "WICProgressNotificationEnd")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs index 57967620fe..23e8a63f13 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs @@ -15,18 +15,6 @@ public enum WICProgressOperation : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"ProgressOperationCopyPixels\"")] - [NativeName("Name", "WICProgressOperationCopyPixels")] - WicprogressOperationCopyPixels = 0x1, - [Obsolete("Deprecated in favour of \"ProgressOperationWritePixels\"")] - [NativeName("Name", "WICProgressOperationWritePixels")] - WicprogressOperationWritePixels = 0x2, - [Obsolete("Deprecated in favour of \"ProgressOperationAll\"")] - [NativeName("Name", "WICProgressOperationAll")] - WicprogressOperationAll = 0xFFFF, - [Obsolete("Deprecated in favour of \"RogressoperationForceDword\"")] - [NativeName("Name", "WICPROGRESSOPERATION_FORCE_DWORD")] - WicprogressoperationForceDword = 0x7FFFFFFF, [NativeName("Name", "WICProgressOperationCopyPixels")] ProgressOperationCopyPixels = 0x1, [NativeName("Name", "WICProgressOperationWritePixels")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs index 3144aa568d..fe646ae075 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICRawCapabilities")] public enum WICRawCapabilities : int { - [Obsolete("Deprecated in favour of \"RawCapabilityNotSupported\"")] - [NativeName("Name", "WICRawCapabilityNotSupported")] - WicrawCapabilityNotSupported = 0x0, - [Obsolete("Deprecated in favour of \"RawCapabilityGetSupported\"")] - [NativeName("Name", "WICRawCapabilityGetSupported")] - WicrawCapabilityGetSupported = 0x1, - [Obsolete("Deprecated in favour of \"RawCapabilityFullySupported\"")] - [NativeName("Name", "WICRawCapabilityFullySupported")] - WicrawCapabilityFullySupported = 0x2, - [Obsolete("Deprecated in favour of \"AwcapabilitiesForceDword\"")] - [NativeName("Name", "WICRAWCAPABILITIES_FORCE_DWORD")] - WicrawcapabilitiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICRawCapabilityNotSupported")] RawCapabilityNotSupported = 0x0, [NativeName("Name", "WICRawCapabilityGetSupported")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs index f72865286e..e40415c6da 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICRawParameterSet")] public enum WICRawParameterSet : int { - [Obsolete("Deprecated in favour of \"AsShotParameterSet\"")] - [NativeName("Name", "WICAsShotParameterSet")] - WicasShotParameterSet = 0x1, - [Obsolete("Deprecated in favour of \"UserAdjustedParameterSet\"")] - [NativeName("Name", "WICUserAdjustedParameterSet")] - WicuserAdjustedParameterSet = 0x2, - [Obsolete("Deprecated in favour of \"AutoAdjustedParameterSet\"")] - [NativeName("Name", "WICAutoAdjustedParameterSet")] - WicautoAdjustedParameterSet = 0x3, - [Obsolete("Deprecated in favour of \"AwparametersetForceDword\"")] - [NativeName("Name", "WICRAWPARAMETERSET_FORCE_DWORD")] - WicrawparametersetForceDword = 0x7FFFFFFF, [NativeName("Name", "WICAsShotParameterSet")] AsShotParameterSet = 0x1, [NativeName("Name", "WICUserAdjustedParameterSet")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs index 2668bbefe5..80f5e1d143 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs @@ -12,18 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICRawRenderMode")] public enum WICRawRenderMode : int { - [Obsolete("Deprecated in favour of \"RawRenderModeDraft\"")] - [NativeName("Name", "WICRawRenderModeDraft")] - WicrawRenderModeDraft = 0x1, - [Obsolete("Deprecated in favour of \"RawRenderModeNormal\"")] - [NativeName("Name", "WICRawRenderModeNormal")] - WicrawRenderModeNormal = 0x2, - [Obsolete("Deprecated in favour of \"RawRenderModeBestQuality\"")] - [NativeName("Name", "WICRawRenderModeBestQuality")] - WicrawRenderModeBestQuality = 0x3, - [Obsolete("Deprecated in favour of \"AwrendermodeForceDword\"")] - [NativeName("Name", "WICRAWRENDERMODE_FORCE_DWORD")] - WicrawrendermodeForceDword = 0x7FFFFFFF, [NativeName("Name", "WICRawRenderModeDraft")] RawRenderModeDraft = 0x1, [NativeName("Name", "WICRawRenderModeNormal")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs index c10d769241..3646178df4 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs @@ -12,21 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICRawRotationCapabilities")] public enum WICRawRotationCapabilities : int { - [Obsolete("Deprecated in favour of \"RawRotationCapabilityNotSupported\"")] - [NativeName("Name", "WICRawRotationCapabilityNotSupported")] - WicrawRotationCapabilityNotSupported = 0x0, - [Obsolete("Deprecated in favour of \"RawRotationCapabilityGetSupported\"")] - [NativeName("Name", "WICRawRotationCapabilityGetSupported")] - WicrawRotationCapabilityGetSupported = 0x1, - [Obsolete("Deprecated in favour of \"RawRotationCapabilityNinetyDegreesSupported\"")] - [NativeName("Name", "WICRawRotationCapabilityNinetyDegreesSupported")] - WicrawRotationCapabilityNinetyDegreesSupported = 0x2, - [Obsolete("Deprecated in favour of \"RawRotationCapabilityFullySupported\"")] - [NativeName("Name", "WICRawRotationCapabilityFullySupported")] - WicrawRotationCapabilityFullySupported = 0x3, - [Obsolete("Deprecated in favour of \"AwrotationcapabilitiesForceDword\"")] - [NativeName("Name", "WICRAWROTATIONCAPABILITIES_FORCE_DWORD")] - WicrawrotationcapabilitiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICRawRotationCapabilityNotSupported")] RawRotationCapabilityNotSupported = 0x0, [NativeName("Name", "WICRawRotationCapabilityGetSupported")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs index 1e51f451a4..cc47553ea8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs @@ -15,15 +15,6 @@ public enum WICSectionAccessLevel : int { [NativeName("Name", "")] None = 0, - [Obsolete("Deprecated in favour of \"Read\"")] - [NativeName("Name", "WICSectionAccessLevelRead")] - WicsectionAccessLevelRead = 0x1, - [Obsolete("Deprecated in favour of \"ReadWrite\"")] - [NativeName("Name", "WICSectionAccessLevelReadWrite")] - WicsectionAccessLevelReadWrite = 0x3, - [Obsolete("Deprecated in favour of \"ForceDword\"")] - [NativeName("Name", "WICSectionAccessLevel_FORCE_DWORD")] - WicsectionAccessLevelForceDword = 0x7FFFFFFF, [NativeName("Name", "WICSectionAccessLevelRead")] Read = 0x1, [NativeName("Name", "WICSectionAccessLevelReadWrite")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs index a617f31d45..4af0387b34 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs @@ -12,33 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICTiffCompressionOption")] public enum WICTiffCompressionOption : int { - [Obsolete("Deprecated in favour of \"TiffCompressionDontCare\"")] - [NativeName("Name", "WICTiffCompressionDontCare")] - WictiffCompressionDontCare = 0x0, - [Obsolete("Deprecated in favour of \"TiffCompressionNone\"")] - [NativeName("Name", "WICTiffCompressionNone")] - WictiffCompressionNone = 0x1, - [Obsolete("Deprecated in favour of \"TiffCompressionCcitt3\"")] - [NativeName("Name", "WICTiffCompressionCCITT3")] - WictiffCompressionCcitt3 = 0x2, - [Obsolete("Deprecated in favour of \"TiffCompressionCcitt4\"")] - [NativeName("Name", "WICTiffCompressionCCITT4")] - WictiffCompressionCcitt4 = 0x3, - [Obsolete("Deprecated in favour of \"TiffCompressionLzw\"")] - [NativeName("Name", "WICTiffCompressionLZW")] - WictiffCompressionLzw = 0x4, - [Obsolete("Deprecated in favour of \"TiffCompressionRle\"")] - [NativeName("Name", "WICTiffCompressionRLE")] - WictiffCompressionRle = 0x5, - [Obsolete("Deprecated in favour of \"TiffCompressionZip\"")] - [NativeName("Name", "WICTiffCompressionZIP")] - WictiffCompressionZip = 0x6, - [Obsolete("Deprecated in favour of \"TiffCompressionLzwhDifferencing\"")] - [NativeName("Name", "WICTiffCompressionLZWHDifferencing")] - WictiffCompressionLzwhdifferencing = 0x7, - [Obsolete("Deprecated in favour of \"IffcompressionoptionForceDword\"")] - [NativeName("Name", "WICTIFFCOMPRESSIONOPTION_FORCE_DWORD")] - WictiffcompressionoptionForceDword = 0x7FFFFFFF, [NativeName("Name", "WICTiffCompressionDontCare")] TiffCompressionDontCare = 0x0, [NativeName("Name", "WICTiffCompressionNone")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs index a24780d776..f0ee2650e6 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICWebpAnimProperties")] public enum WICWebpAnimProperties : int { - [Obsolete("Deprecated in favour of \"LoopCount\"")] - [NativeName("Name", "WICWebpAnimLoopCount")] - WicwebpAnimLoopCount = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICWebpAnimProperties_FORCE_DWORD")] - WicwebpAnimPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICWebpAnimLoopCount")] LoopCount = 0x1, [NativeName("Name", "WICWebpAnimProperties_FORCE_DWORD")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs index 5be01c3fea..449ba4ee22 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs @@ -12,12 +12,6 @@ namespace Silk.NET.WindowsCodecs [NativeName("Name", "WICWebpAnmfProperties")] public enum WICWebpAnmfProperties : int { - [Obsolete("Deprecated in favour of \"FrameDuration\"")] - [NativeName("Name", "WICWebpAnmfFrameDuration")] - WicwebpAnmfFrameDuration = 0x1, - [Obsolete("Deprecated in favour of \"PropertiesForceDword\"")] - [NativeName("Name", "WICWebpAnmfProperties_FORCE_DWORD")] - WicwebpAnmfPropertiesForceDword = 0x7FFFFFFF, [NativeName("Name", "WICWebpAnmfFrameDuration")] FrameDuration = 0x1, [NativeName("Name", "WICWebpAnmfProperties_FORCE_DWORD")] From ea430aafda54218947bc56360235909651d05d84 Mon Sep 17 00:00:00 2001 From: Steven He Date: Sat, 23 Sep 2023 17:49:58 +0900 Subject: [PATCH 3/7] Remove tag prefix --- build/cache/win32extras.json.gz | Bin 280774 -> 280774 bytes generator.json | 44 +- ...ATIONTYPE.gen.cs => ActivationType.gen.cs} | 2 +- .../{TagADVF.gen.cs => AdviseFlag.gen.cs} | 2 +- ...tionType.gen.cs => ApplicationType.gen.cs} | 2 +- .../{TagBINDFLAGS.gen.cs => BindFlags.gen.cs} | 2 +- .../Enums/{TagCLSCTX.gen.cs => CLSCTX.gen.cs} | 2 +- .../{TagCALLTYPE.gen.cs => CallType.gen.cs} | 2 +- .../{TagDATADIR.gen.cs => DATADIR.gen.cs} | 2 +- ...MCALLSTATE.gen.cs => DCOMCallState.gen.cs} | 2 +- .../{TagEXTCONN.gen.cs => EXTCONN.gen.cs} | 2 +- ... => EoleAuthenticationCapabilities.gen.cs} | 2 +- ...VALUES.gen.cs => GlobalOptEHValues.gen.cs} | 2 +- ...TIES.gen.cs => GlobalOptProperties.gen.cs} | 2 +- ...UES.gen.cs => GlobalOptRPCTPValues.gen.cs} | 2 +- ...ROFLAGS.gen.cs => GlobalOptRoFlags.gen.cs} | 2 +- ... => GlobalUnmarshalingPolicyValues.gen.cs} | 2 +- .../{TagLOCKTYPE.gen.cs => LockType.gen.cs} | 2 +- .../Enums/{TagMEMCTX.gen.cs => MEMCTX.gen.cs} | 2 +- .../{TagMKREDUCE.gen.cs => MKRREDUCE.gen.cs} | 2 +- .../Enums/{TagMKSYS.gen.cs => MKSYS.gen.cs} | 2 +- .../Enums/{TagMSHCTX.gen.cs => MSHCTX.gen.cs} | 2 +- .../{TagMSHLFLAGS.gen.cs => MSHLFlags.gen.cs} | 2 +- ...TagPENDINGMSG.gen.cs => PendingMsg.gen.cs} | 2 +- ...gPENDINGTYPE.gen.cs => PendingType.gen.cs} | 2 +- ...PERTIES.gen.cs => RPCOptProperties.gen.cs} | 2 +- ...n.cs => RPCOptServerLocalityValues.gen.cs} | 2 +- .../Enums/{TagSTGTY.gen.cs => STGTY.gen.cs} | 2 +- ...TagSERVERCALL.gen.cs => ServerCall.gen.cs} | 2 +- ...hutdownType.gen.cs => ShutdownType.gen.cs} | 2 +- ...TagSTREAMSEEK.gen.cs => StreamSeek.gen.cs} | 2 +- .../Enums/{TagTYMED.gen.cs => TYMED.gen.cs} | 2 +- .../Structs/AdviseSink2VtblExtensions.gen.cs | 30 +- .../Structs/AdviseSinkVtblExtensions.gen.cs | 30 +- .../Structs/AsyncIAdviseSink.gen.cs | 24 +- .../Structs/AsyncIAdviseSink2.gen.cs | 24 +- .../AsyncIAdviseSink2VtblExtensions.gen.cs | 30 +- .../AsyncIAdviseSinkVtblExtensions.gen.cs | 30 +- .../Structs/BindCtxVtblExtensions.gen.cs | 24 +- .../{TagBINDOPTS.gen.cs => BindOpts.gen.cs} | 4 +- .../{TagBINDOPTS2.gen.cs => BindOpts2.gen.cs} | 4 +- .../{TagBINDOPTS3.gen.cs => BindOpts3.gen.cs} | 4 +- ...GETDEVICE.gen.cs => DVTargetDevice.gen.cs} | 4 +- .../DataAdviseHolderVtblExtensions.gen.cs | 134 +-- .../Structs/DataObjectVtblExtensions.gen.cs | 194 ++-- .../EnumFORMATETCVtblExtensions.gen.cs | 26 +- .../Structs/EnumSTATDATAVtblExtensions.gen.cs | 26 +- .../{TagFORMATETC.gen.cs => FORMATETC.gen.cs} | 8 +- .../Structs/FlagStgmedium.gen.cs | 4 +- .../GlobalOptionsVtblExtensions.gen.cs | 14 +- .../Structs/IAdviseSink.gen.cs | 24 +- .../Structs/IAdviseSink2.gen.cs | 24 +- .../Structs/IBindCtx.gen.cs | 20 +- .../Structs/IDataAdviseHolder.gen.cs | 104 +- .../Structs/IDataObject.gen.cs | 154 +-- .../Structs/IEnumFORMATETC.gen.cs | 20 +- .../Structs/IEnumSTATDATA.gen.cs | 20 +- .../Structs/IGlobalOptions.gen.cs | 12 +- .../Structs/ILayoutStorage.gen.cs | 10 +- .../Structs/IMessageFilter.gen.cs | 20 +- .../Structs/IRpcOptions.gen.cs | 30 +- .../Structs/ISurrogateService.gen.cs | 12 +- ...ERFACEINFO.gen.cs => InterfaceInfo.gen.cs} | 4 +- .../LayoutStorageVtblExtensions.gen.cs | 12 +- .../MessageFilterVtblExtensions.gen.cs | 26 +- .../{TagRemSNB.gen.cs => RemSNB.gen.cs} | 4 +- ...emSTGMEDIUM.gen.cs => RemSTGMEDIUM.gen.cs} | 4 +- .../Structs/RpcOptionsVtblExtensions.gen.cs | 38 +- .../{TagSTATDATA.gen.cs => STATDATA.gen.cs} | 8 +- .../{TagSTGMEDIUM.gen.cs => STGMEDIUM.gen.cs} | 8 +- ...DIUMUnion.gen.cs => STGMEDIUMUnion.gen.cs} | 4 +- ...rageLayout.gen.cs => StorageLayout.gen.cs} | 4 +- .../SurrogateServiceVtblExtensions.gen.cs | 14 +- .../Silk.NET.Core.Win32Extras/Windows.gen.cs | 1024 ++++++++--------- .../WindowsOverloads.gen.cs | 538 ++++----- .../netstandard2.1/PublicAPI.Shipped.txt | 1 + .../netstandard2.1/PublicAPI.Unshipped.txt | 1 + 77 files changed, 1451 insertions(+), 1407 deletions(-) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagACTIVATIONTYPE.gen.cs => ActivationType.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagADVF.gen.cs => AdviseFlag.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagApplicationType.gen.cs => ApplicationType.gen.cs} (92%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagBINDFLAGS.gen.cs => BindFlags.gen.cs} (95%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagCLSCTX.gen.cs => CLSCTX.gen.cs} (99%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagCALLTYPE.gen.cs => CallType.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagDATADIR.gen.cs => DATADIR.gen.cs} (95%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagDCOMCALLSTATE.gen.cs => DCOMCallState.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagEXTCONN.gen.cs => EXTCONN.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagEOLEAUTHENTICATIONCAPABILITIES.gen.cs => EoleAuthenticationCapabilities.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagGLOBALOPTEHVALUES.gen.cs => GlobalOptEHValues.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagGLOBALOPTPROPERTIES.gen.cs => GlobalOptProperties.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagGLOBALOPTRPCTPVALUES.gen.cs => GlobalOptRPCTPValues.gen.cs} (95%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagGLOBALOPTROFLAGS.gen.cs => GlobalOptRoFlags.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagGLOBALOPTUNMARSHALINGPOLICYVALUES.gen.cs => GlobalUnmarshalingPolicyValues.gen.cs} (94%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagLOCKTYPE.gen.cs => LockType.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagMEMCTX.gen.cs => MEMCTX.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagMKREDUCE.gen.cs => MKRREDUCE.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagMKSYS.gen.cs => MKSYS.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagMSHCTX.gen.cs => MSHCTX.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagMSHLFLAGS.gen.cs => MSHLFlags.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagPENDINGMSG.gen.cs => PendingMsg.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagPENDINGTYPE.gen.cs => PendingType.gen.cs} (95%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagRPCOPTPROPERTIES.gen.cs => RPCOptProperties.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagRPCOPTSERVERLOCALITYVALUES.gen.cs => RPCOptServerLocalityValues.gen.cs} (95%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagSTGTY.gen.cs => STGTY.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagSERVERCALL.gen.cs => ServerCall.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagShutdownType.gen.cs => ShutdownType.gen.cs} (92%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagSTREAMSEEK.gen.cs => StreamSeek.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{TagTYMED.gen.cs => TYMED.gen.cs} (98%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagBINDOPTS.gen.cs => BindOpts.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagBINDOPTS2.gen.cs => BindOpts2.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagBINDOPTS3.gen.cs => BindOpts3.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagDVTARGETDEVICE.gen.cs => DVTargetDevice.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagFORMATETC.gen.cs => FORMATETC.gen.cs} (92%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagINTERFACEINFO.gen.cs => InterfaceInfo.gen.cs} (94%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagRemSNB.gen.cs => RemSNB.gen.cs} (95%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagRemSTGMEDIUM.gen.cs => RemSTGMEDIUM.gen.cs} (96%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagSTATDATA.gen.cs => STATDATA.gen.cs} (91%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagSTGMEDIUM.gen.cs => STGMEDIUM.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagSTGMEDIUMUnion.gen.cs => STGMEDIUMUnion.gen.cs} (97%) rename src/Core/Silk.NET.Core.Win32Extras/Structs/{TagStorageLayout.gen.cs => StorageLayout.gen.cs} (95%) create mode 100644 src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt create mode 100644 src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt diff --git a/build/cache/win32extras.json.gz b/build/cache/win32extras.json.gz index f160abe892b85c9f4b8aa9d5df5550a0901f5835..cf699e1870d1263aa9661b6c61ba20e82cbbfc16 100644 GIT binary patch literal 280774 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 z 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%0Ddx+r-&qw)~AtomwmvkUk5F1KyB@=$8U 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 z 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

9dt;-CGb7v1ir6`Y+X9W(k};m2PKuT+P`3cwsZ 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 OCsb{P+L+;^fd2ycaedDK literal 280774 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

GVIcnH}SRB9#0e*lC~>7T@fwOOzlD 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 LFi{G?`Fqp=KEUmY diff --git a/generator.json b/generator.json index baacdb13cd..db3a345ac6 100644 --- a/generator.json +++ b/generator.json @@ -1043,7 +1043,49 @@ "tagSOLE_AUTHENTICATION_LIST": "SoleAuthenticationList", "tagSOLE_AUTHENTICATION_SERVICE": "SoleAuthenticationService", "tagSOLE_AUTHENTICATION_INFO": "SoleAuthenticationInfo", - "tagSTATSTG": "STATSTG" + "tagSTATSTG": "STATSTG", + "tagACTIVATIONTYPE": "ActivationType", + "tagCLSCTX": "CLSCTX", + "tagDCOM_CALL_STATE": "DCOMCallState", + "tagEOLE_AUTHENTICATION_CAPABILITIES": "EoleAuthenticationCapabilities", + "tagEXTCONN": "EXTCONN", + "tagGLOBALOPT_EH_VALUES": "GlobalOptEHValues", + "tagGLOBALOPT_PROPERTIES": "GlobalOptProperties", + "tagGLOBALOPT_RO_FLAGS": "GlobalOptRoFlags", + "tagGLOBALOPT_RPCTP_VALUES": "GlobalOptRPCTPValues", + "tagGLOBALOPT_UNMARSHALING_POLICY_VALUES": "GlobalUnmarshalingPolicyValues", + "tagLOCKTYPE": "LockType", + "tagMEMCTX": "MEMCTX", + "tagMSHCTX": "MSHCTX", + "tagMSHLFLAGS": "MSHLFlags", + "tagRPCOPT_PROPERTIES": "RPCOptProperties", + "tagRPCOPT_SERVER_LOCALITY_VALUES": "RPCOptServerLocalityValues", + "tagSTGTY": "STGTY", + "tagSTREAM_SEEK": "StreamSeek", + "tagADVF": "AdviseFlag", + "tagApplicationType": "ApplicationType", + "tagBIND_FLAGS": "BindFlags", + "tagCALLTYPE": "CallType", + "tagDATADIR": "DATADIR", + "tagMKREDUCE": "MKRREDUCE", + "tagMKSYS": "MKSYS", + "tagPENDINGMSG": "PendingMsg", + "tagPENDINGTYPE": "PendingType", + "tagSERVERCALL": "ServerCall", + "tagShutdownType": "ShutdownType", + "tagTYMED": "TYMED", + "tagBIND_OPTS": "BindOpts", + "tagBIND_OPTS2": "BindOpts2", + "tagBIND_OPTS3": "BindOpts3", + "tagDVTARGETDEVICE": "DVTargetDevice", + "tagFORMATETC": "FORMATETC", + "tagINTERFACEINFO": "InterfaceInfo", + "tagRemSNB": "RemSNB", + "tagRemSTGMEDIUM": "RemSTGMEDIUM", + "tagSTATDATA": "STATDATA", + "tagSTGMEDIUM": "STGMEDIUM", + "TagSTGMEDIUMUnion": "STGMEDIUMUnion", + "tagStorageLayout": "StorageLayout" }, "bakery": { "profileNames": [ diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagACTIVATIONTYPE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ActivationType.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagACTIVATIONTYPE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/ActivationType.gen.cs index 1d6b0adb6b..5e2cb18fde 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagACTIVATIONTYPE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ActivationType.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagACTIVATIONTYPE")] - public enum TagACTIVATIONTYPE : int + public enum ActivationType : int { [Obsolete("Deprecated in favour of \"Uncategorized\"")] [NativeName("Name", "ACTIVATIONTYPE_UNCATEGORIZED")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/AdviseFlag.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/AdviseFlag.gen.cs index 39927568b6..67a5599e6e 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagADVF.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/AdviseFlag.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagADVF")] - public enum TagADVF : int + public enum AdviseFlag : int { [NativeName("Name", "")] None = 0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ApplicationType.gen.cs similarity index 92% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/ApplicationType.gen.cs index 4d56c908fd..16ba3ce263 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagApplicationType.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ApplicationType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagApplicationType")] - public enum TagApplicationType : int + public enum ApplicationType : int { [NativeName("Name", "ServerApplication")] ServerApplication = 0x0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/BindFlags.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/BindFlags.gen.cs index 421dd594cd..ae736727cf 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagBINDFLAGS.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/BindFlags.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagBIND_FLAGS")] - public enum TagBINDFLAGS : int + public enum BindFlags : int { [Obsolete("Deprecated in favour of \"Maybotheruser\"")] [NativeName("Name", "BIND_MAYBOTHERUSER")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCLSCTX.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/CLSCTX.gen.cs similarity index 99% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagCLSCTX.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/CLSCTX.gen.cs index e7328de54d..36f5d2227b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCLSCTX.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/CLSCTX.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagCLSCTX")] - public enum TagCLSCTX : int + public enum CLSCTX : int { [NativeName("Name", "")] None = 0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/CallType.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/CallType.gen.cs index f169632b96..4adcb22007 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagCALLTYPE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/CallType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagCALLTYPE")] - public enum TagCALLTYPE : int + public enum CallType : int { [Obsolete("Deprecated in favour of \"Toplevel\"")] [NativeName("Name", "CALLTYPE_TOPLEVEL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/DATADIR.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/DATADIR.gen.cs index 9962e8a729..1156e969d0 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDATADIR.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/DATADIR.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagDATADIR")] - public enum TagDATADIR : int + public enum DATADIR : int { [Obsolete("Deprecated in favour of \"Get\"")] [NativeName("Name", "DATADIR_GET")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDCOMCALLSTATE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/DCOMCallState.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagDCOMCALLSTATE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/DCOMCallState.gen.cs index 393726e350..12477a1303 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagDCOMCALLSTATE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/DCOMCallState.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagDCOM_CALL_STATE")] - public enum TagDCOMCALLSTATE : int + public enum DCOMCallState : int { [Obsolete("Deprecated in favour of \"None\"")] [NativeName("Name", "DCOM_NONE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagEXTCONN.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/EXTCONN.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagEXTCONN.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/EXTCONN.gen.cs index da3cc14816..e054aa1e77 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagEXTCONN.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/EXTCONN.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagEXTCONN")] - public enum TagEXTCONN : int + public enum EXTCONN : int { [Obsolete("Deprecated in favour of \"Strong\"")] [NativeName("Name", "EXTCONN_STRONG")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagEOLEAUTHENTICATIONCAPABILITIES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/EoleAuthenticationCapabilities.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagEOLEAUTHENTICATIONCAPABILITIES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/EoleAuthenticationCapabilities.gen.cs index 8e732eda35..d4dfd21fbd 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagEOLEAUTHENTICATIONCAPABILITIES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/EoleAuthenticationCapabilities.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagEOLE_AUTHENTICATION_CAPABILITIES")] - public enum TagEOLEAUTHENTICATIONCAPABILITIES : int + public enum EoleAuthenticationCapabilities : int { [Obsolete("Deprecated in favour of \"None\"")] [NativeName("Name", "EOAC_NONE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTEHVALUES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptEHValues.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTEHVALUES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptEHValues.gen.cs index 551e57c851..bfe436291b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTEHVALUES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptEHValues.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagGLOBALOPT_EH_VALUES")] - public enum TagGLOBALOPTEHVALUES : int + public enum GlobalOptEHValues : int { [Obsolete("Deprecated in favour of \"Handle\"")] [NativeName("Name", "COMGLB_EXCEPTION_HANDLE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTPROPERTIES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptProperties.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTPROPERTIES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptProperties.gen.cs index f51d16e4b6..6b3eaab499 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTPROPERTIES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagGLOBALOPT_PROPERTIES")] - public enum TagGLOBALOPTPROPERTIES : int + public enum GlobalOptProperties : int { [Obsolete("Deprecated in favour of \"ExceptionHandling\"")] [NativeName("Name", "COMGLB_EXCEPTION_HANDLING")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTRPCTPVALUES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptRPCTPValues.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTRPCTPVALUES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptRPCTPValues.gen.cs index 3618f330b4..fff8f94da9 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTRPCTPVALUES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptRPCTPValues.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagGLOBALOPT_RPCTP_VALUES")] - public enum TagGLOBALOPTRPCTPVALUES : int + public enum GlobalOptRPCTPValues : int { [Obsolete("Deprecated in favour of \"DefaultPool\"")] [NativeName("Name", "COMGLB_RPC_THREADPOOL_SETTING_DEFAULT_POOL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTROFLAGS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptRoFlags.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTROFLAGS.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptRoFlags.gen.cs index ab19750d1d..2a0a501c27 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTROFLAGS.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalOptRoFlags.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagGLOBALOPT_RO_FLAGS")] - public enum TagGLOBALOPTROFLAGS : int + public enum GlobalOptRoFlags : int { [NativeName("Name", "")] None = 0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTUNMARSHALINGPOLICYVALUES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalUnmarshalingPolicyValues.gen.cs similarity index 94% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTUNMARSHALINGPOLICYVALUES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalUnmarshalingPolicyValues.gen.cs index 0b19d7ceed..f83b1a8fd6 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagGLOBALOPTUNMARSHALINGPOLICYVALUES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/GlobalUnmarshalingPolicyValues.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagGLOBALOPT_UNMARSHALING_POLICY_VALUES")] - public enum TagGLOBALOPTUNMARSHALINGPOLICYVALUES : int + public enum GlobalUnmarshalingPolicyValues : int { [Obsolete("Deprecated in favour of \"Normal\"")] [NativeName("Name", "COMGLB_UNMARSHALING_POLICY_NORMAL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagLOCKTYPE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/LockType.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagLOCKTYPE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/LockType.gen.cs index 027ad7e4ae..b6fc49308c 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagLOCKTYPE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/LockType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagLOCKTYPE")] - public enum TagLOCKTYPE : int + public enum LockType : int { [Obsolete("Deprecated in favour of \"Write\"")] [NativeName("Name", "LOCK_WRITE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMEMCTX.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/MEMCTX.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagMEMCTX.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/MEMCTX.gen.cs index 8269090777..95c8e87bda 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMEMCTX.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/MEMCTX.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagMEMCTX")] - public enum TagMEMCTX : int + public enum MEMCTX : int { [NativeName("Name", "")] None = 0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/MKRREDUCE.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/MKRREDUCE.gen.cs index a39ae6e118..3ab471885d 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKREDUCE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/MKRREDUCE.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagMKREDUCE")] - public enum TagMKREDUCE : int + public enum MKRREDUCE : int { [Obsolete("Deprecated in favour of \"One\"")] [NativeName("Name", "MKRREDUCE_ONE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/MKSYS.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/MKSYS.gen.cs index 6f76e50214..3246a3e3f4 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMKSYS.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/MKSYS.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagMKSYS")] - public enum TagMKSYS : int + public enum MKSYS : int { [Obsolete("Deprecated in favour of \"None\"")] [NativeName("Name", "MKSYS_NONE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMSHCTX.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/MSHCTX.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagMSHCTX.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/MSHCTX.gen.cs index 79176ca6d5..66f0c21d6b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMSHCTX.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/MSHCTX.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagMSHCTX")] - public enum TagMSHCTX : int + public enum MSHCTX : int { [Obsolete("Deprecated in favour of \"Local\"")] [NativeName("Name", "MSHCTX_LOCAL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMSHLFLAGS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/MSHLFlags.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagMSHLFLAGS.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/MSHLFlags.gen.cs index 1833049ce2..80701a656b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagMSHLFLAGS.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/MSHLFlags.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagMSHLFLAGS")] - public enum TagMSHLFLAGS : int + public enum MSHLFlags : int { [Obsolete("Deprecated in favour of \"Normal\"")] [NativeName("Name", "MSHLFLAGS_NORMAL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PendingMsg.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/PendingMsg.gen.cs index e1895d033c..bf8ba9bbe8 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGMSG.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PendingMsg.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagPENDINGMSG")] - public enum TagPENDINGMSG : int + public enum PendingMsg : int { [Obsolete("Deprecated in favour of \"Cancelcall\"")] [NativeName("Name", "PENDINGMSG_CANCELCALL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/PendingType.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/PendingType.gen.cs index 7bb72d1832..db3c9a54e7 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagPENDINGTYPE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/PendingType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagPENDINGTYPE")] - public enum TagPENDINGTYPE : int + public enum PendingType : int { [Obsolete("Deprecated in favour of \"Toplevel\"")] [NativeName("Name", "PENDINGTYPE_TOPLEVEL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagRPCOPTPROPERTIES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/RPCOptProperties.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagRPCOPTPROPERTIES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/RPCOptProperties.gen.cs index 0c5504d511..1691f7db1d 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagRPCOPTPROPERTIES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/RPCOptProperties.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagRPCOPT_PROPERTIES")] - public enum TagRPCOPTPROPERTIES : int + public enum RPCOptProperties : int { [NativeName("Name", "")] None = 0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagRPCOPTSERVERLOCALITYVALUES.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/RPCOptServerLocalityValues.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagRPCOPTSERVERLOCALITYVALUES.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/RPCOptServerLocalityValues.gen.cs index dce922fd48..eb15727743 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagRPCOPTSERVERLOCALITYVALUES.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/RPCOptServerLocalityValues.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagRPCOPT_SERVER_LOCALITY_VALUES")] - public enum TagRPCOPTSERVERLOCALITYVALUES : int + public enum RPCOptServerLocalityValues : int { [Obsolete("Deprecated in favour of \"ProcessLocal\"")] [NativeName("Name", "SERVER_LOCALITY_PROCESS_LOCAL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSTGTY.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/STGTY.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagSTGTY.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/STGTY.gen.cs index 3f469f2084..f796571953 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSTGTY.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/STGTY.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagSTGTY")] - public enum TagSTGTY : int + public enum STGTY : int { [Obsolete("Deprecated in favour of \"Storage\"")] [NativeName("Name", "STGTY_STORAGE")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ServerCall.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/ServerCall.gen.cs index 9e14a0dbdf..ee4c60b8b5 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSERVERCALL.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ServerCall.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagSERVERCALL")] - public enum TagSERVERCALL : int + public enum ServerCall : int { [Obsolete("Deprecated in favour of \"Ishandled\"")] [NativeName("Name", "SERVERCALL_ISHANDLED")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/ShutdownType.gen.cs similarity index 92% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/ShutdownType.gen.cs index 0055d18dde..42917bd6a8 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagShutdownType.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/ShutdownType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagShutdownType")] - public enum TagShutdownType : int + public enum ShutdownType : int { [NativeName("Name", "IdleShutdown")] IdleShutdown = 0x0, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSTREAMSEEK.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/StreamSeek.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagSTREAMSEEK.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/StreamSeek.gen.cs index 63d35b4320..397ad1448b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagSTREAMSEEK.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/StreamSeek.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagSTREAM_SEEK")] - public enum TagSTREAMSEEK : int + public enum StreamSeek : int { [Obsolete("Deprecated in favour of \"Set\"")] [NativeName("Name", "STREAM_SEEK_SET")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Enums/TYMED.gen.cs similarity index 98% rename from src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Enums/TYMED.gen.cs index 5690053fe7..844df5cfc3 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Enums/TagTYMED.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Enums/TYMED.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.Core.Win32Extras { [Flags] [NativeName("Name", "tagTYMED")] - public enum TagTYMED : int + public enum TYMED : int { [Obsolete("Deprecated in favour of \"Hglobal\"")] [NativeName("Name", "TYMED_HGLOBAL")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs index 76e6171726..965e7a2005 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSink2VtblExtensions.gen.cs @@ -85,41 +85,41 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public static void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public static void OnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } @@ -205,7 +205,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Span } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -213,7 +213,7 @@ public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFO } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -221,7 +221,7 @@ public static unsafe void OnDataChange(this ComPtr thisVtbl, Span< } /// To be documented. - public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs index a47e792c01..5f1c0f0bf8 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AdviseSinkVtblExtensions.gen.cs @@ -85,41 +85,41 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public static void OnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public static void OnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } @@ -188,7 +188,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -196,7 +196,7 @@ public static unsafe void OnDataChange(this ComPtr thisVtbl, TagFOR } /// To be documented. - public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -204,7 +204,7 @@ public static unsafe void OnDataChange(this ComPtr thisVtbl, SpanTo be documented. - public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + public static void OnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs index 53bdfe1a70..992bc01c07 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink.gen.cs @@ -111,41 +111,41 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void BeginOnDataChange(FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly unsafe void BeginOnDataChange(FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public readonly unsafe void BeginOnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void BeginOnDataChange(ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public readonly void BeginOnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly void BeginOnDataChange(ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = (AsyncIAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs index a60f6a3248..189a774ce2 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2.gen.cs @@ -114,41 +114,41 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void BeginOnDataChange(FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public readonly unsafe void BeginOnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly unsafe void BeginOnDataChange(FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public readonly unsafe void BeginOnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void BeginOnDataChange(ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public readonly void BeginOnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly void BeginOnDataChange(ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = (AsyncIAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs index 6bd6b99012..6d6ade15a6 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSink2VtblExtensions.gen.cs @@ -85,41 +85,41 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public static void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public static void BeginOnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } @@ -247,7 +247,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -255,7 +255,7 @@ public static unsafe void BeginOnDataChange(this ComPtr thisV } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -263,7 +263,7 @@ public static unsafe void BeginOnDataChange(this ComPtr thisV } /// To be documented. - public static void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + public static void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs index 1cf957543d..64f59c7191 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/AsyncIAdviseSinkVtblExtensions.gen.cs @@ -85,41 +85,41 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public static void BeginOnDataChange(this ComPtr thisVtbl, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public static void BeginOnDataChange(this ComPtr thisVtbl, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = thisVtbl.Handle; - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } @@ -223,7 +223,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, FORMATETC* pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -231,7 +231,7 @@ public static unsafe void BeginOnDataChange(this ComPtr thisVt } /// To be documented. - public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, STGMEDIUM* pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader @@ -239,7 +239,7 @@ public static unsafe void BeginOnDataChange(this ComPtr thisVt } /// To be documented. - public static void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) + public static void BeginOnDataChange(this ComPtr thisVtbl, Span pFormatetc, Span pStgmed) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs index c3d9b1aff1..dafbaf310d 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindCtxVtblExtensions.gen.cs @@ -136,43 +136,43 @@ public static int ReleaseBoundObjects(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int SetBindOptions(this ComPtr thisVtbl, TagBINDOPTS* pbindopts) + public static unsafe int SetBindOptions(this ComPtr thisVtbl, BindOpts* pbindopts) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindopts); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindopts); return ret; } /// To be documented. - public static int SetBindOptions(this ComPtr thisVtbl, ref TagBINDOPTS pbindopts) + public static int SetBindOptions(this ComPtr thisVtbl, ref BindOpts pbindopts) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + fixed (BindOpts* pbindoptsPtr = &pbindopts) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindoptsPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindoptsPtr); } return ret; } /// To be documented. - public static unsafe int GetBindOptions(this ComPtr thisVtbl, TagBINDOPTS* pbindopts) + public static unsafe int GetBindOptions(this ComPtr thisVtbl, BindOpts* pbindopts) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindopts); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindopts); return ret; } /// To be documented. - public static int GetBindOptions(this ComPtr thisVtbl, ref TagBINDOPTS pbindopts) + public static int GetBindOptions(this ComPtr thisVtbl, ref BindOpts pbindopts) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + fixed (BindOpts* pbindoptsPtr = &pbindopts) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindoptsPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindoptsPtr); } return ret; } @@ -455,7 +455,7 @@ public static int RevokeObjectBound(this ComPtr thisVtbl, SpanTo be documented. - public static int SetBindOptions(this ComPtr thisVtbl, Span pbindopts) + public static int SetBindOptions(this ComPtr thisVtbl, Span pbindopts) { var @this = thisVtbl.Handle; // SpanOverloader @@ -463,7 +463,7 @@ public static int SetBindOptions(this ComPtr thisVtbl, SpanTo be documented. - public static int GetBindOptions(this ComPtr thisVtbl, Span pbindopts) + public static int GetBindOptions(this ComPtr thisVtbl, Span pbindopts) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts.gen.cs index eb09885826..fa5878a820 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagBIND_OPTS")] - public unsafe partial struct TagBINDOPTS + public unsafe partial struct BindOpts { - public TagBINDOPTS + public BindOpts ( uint? cbStruct = null, uint? grfFlags = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts2.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts2.gen.cs index 5556d88dac..3120766eeb 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS2.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts2.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagBIND_OPTS2")] - public unsafe partial struct TagBINDOPTS2 + public unsafe partial struct BindOpts2 { - public TagBINDOPTS2 + public BindOpts2 ( uint? cbStruct = null, uint? grfFlags = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts3.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts3.gen.cs index 32845dd58b..c47e5dcc5c 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagBINDOPTS3.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/BindOpts3.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagBIND_OPTS3")] - public unsafe partial struct TagBINDOPTS3 + public unsafe partial struct BindOpts3 { - public TagBINDOPTS3 + public BindOpts3 ( uint? dwTrackFlags = null, uint? dwClassContext = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DVTargetDevice.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/DVTargetDevice.gen.cs index 3e76f9f321..35c17776aa 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagDVTARGETDEVICE.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DVTargetDevice.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagDVTARGETDEVICE")] - public unsafe partial struct TagDVTARGETDEVICE + public unsafe partial struct DVTargetDevice { - public TagDVTARGETDEVICE + public DVTargetDevice ( uint? tdSize = null, ushort? tdDriverNameOffset = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs index ccb3dee971..e9af96f2cd 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataAdviseHolderVtblExtensions.gen.cs @@ -85,40 +85,40 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnection); return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnectionPtr); } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnection); } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; @@ -126,66 +126,66 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnectionPtr); } } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnection); } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnectionPtr); } } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnection); } } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); } } } @@ -193,19 +193,19 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnection); } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; @@ -213,14 +213,14 @@ public static unsafe int Advise(this ComPtr thisVtbl, ref IDa { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnectionPtr); } } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; @@ -228,14 +228,14 @@ public static unsafe int Advise(this ComPtr thisVtbl, ref IDa { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnection); } } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; @@ -245,7 +245,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, ref IDa { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnectionPtr); } } } @@ -253,32 +253,32 @@ public static unsafe int Advise(this ComPtr thisVtbl, ref IDa } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnection); } } return ret; } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnectionPtr); } } } @@ -286,17 +286,17 @@ public static unsafe int Advise(this ComPtr thisVtbl, ref IDa } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnection); } } } @@ -304,19 +304,19 @@ public static unsafe int Advise(this ComPtr thisVtbl, ref IDa } /// To be documented. - public static int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public static int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); } } } @@ -401,7 +401,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -409,7 +409,7 @@ public static unsafe int Advise(this ComPtr thisVtb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -417,7 +417,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -425,7 +425,7 @@ public static unsafe int Advise(this ComPtr thisVtb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, Span pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -433,7 +433,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -441,7 +441,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, Co } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, FORMATETC* pFetc, uint advf, Span pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -449,7 +449,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -457,7 +457,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, Co } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -465,7 +465,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -473,7 +473,7 @@ public static unsafe int Advise(this ComPtr thisVtb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -481,7 +481,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -489,7 +489,7 @@ public static int Advise(this ComPtr thisVtbl, ComP } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, Span pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, Span pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -497,7 +497,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -505,7 +505,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, Co } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, Span pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, IDataObject* pDataObject, Span pFetc, uint advf, Span pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -513,7 +513,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, IDataOb } /// To be documented. - public static int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Advise(this ComPtr thisVtbl, ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -521,7 +521,7 @@ public static int Advise(this ComPtr thisVtbl, ComPtrTo be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -529,7 +529,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -537,7 +537,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, re } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -545,7 +545,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -553,7 +553,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, re } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, FORMATETC* pFetc, uint advf, Span pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -561,7 +561,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, TagFORMATETC* pFetc, uint advf, Span pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, FORMATETC* pFetc, uint advf, Span pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -569,7 +569,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -577,7 +577,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -585,7 +585,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, re } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, IAdviseSink* pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -593,7 +593,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Advise(this ComPtr thisVtbl, ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -601,7 +601,7 @@ public static int Advise(this ComPtr thisVtbl, ref IData } /// To be documented. - public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, Span pAdvise, uint* pdwConnection) + public static unsafe int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, Span pAdvise, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -609,7 +609,7 @@ public static unsafe int Advise(this ComPtr thisVtbl, SpanTo be documented. - public static int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, Span pAdvise, Span pdwConnection) + public static int Advise(this ComPtr thisVtbl, Span pDataObject, Span pFetc, uint advf, Span pAdvise, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs index fda2e68d3b..93541aaa64 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/DataObjectVtblExtensions.gen.cs @@ -85,213 +85,213 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) + public static unsafe int GetData(this ComPtr thisVtbl, FORMATETC* pformatetcIn, STGMEDIUM* pmedium) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmedium); return ret; } /// To be documented. - public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium) + public static unsafe int GetData(this ComPtr thisVtbl, FORMATETC* pformatetcIn, ref STGMEDIUM pmedium) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmediumPtr); } return ret; } /// To be documented. - public static unsafe int GetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium) + public static unsafe int GetData(this ComPtr thisVtbl, ref FORMATETC pformatetcIn, STGMEDIUM* pmedium) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + fixed (FORMATETC* pformatetcInPtr = &pformatetcIn) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmedium); } return ret; } /// To be documented. - public static int GetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium) + public static int GetData(this ComPtr thisVtbl, ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + fixed (FORMATETC* pformatetcInPtr = &pformatetcIn) { - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmediumPtr); } } return ret; } /// To be documented. - public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) + public static unsafe int GetDataHere(this ComPtr thisVtbl, FORMATETC* pformatetc, STGMEDIUM* pmedium) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmedium); return ret; } /// To be documented. - public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium) + public static unsafe int GetDataHere(this ComPtr thisVtbl, FORMATETC* pformatetc, ref STGMEDIUM pmedium) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmediumPtr); } return ret; } /// To be documented. - public static unsafe int GetDataHere(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium) + public static unsafe int GetDataHere(this ComPtr thisVtbl, ref FORMATETC pformatetc, STGMEDIUM* pmedium) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmedium); } return ret; } /// To be documented. - public static int GetDataHere(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium) + public static int GetDataHere(this ComPtr thisVtbl, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmediumPtr); } } return ret; } /// To be documented. - public static unsafe int QueryGetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc) + public static unsafe int QueryGetData(this ComPtr thisVtbl, FORMATETC* pformatetc) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetc); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetc); return ret; } /// To be documented. - public static int QueryGetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetc) + public static int QueryGetData(this ComPtr thisVtbl, ref FORMATETC pformatetc) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetcPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetcPtr); } return ret; } /// To be documented. - public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, TagFORMATETC* pformatectIn, TagFORMATETC* pformatetcOut) + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, FORMATETC* pformatectIn, FORMATETC* pformatetcOut) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOut); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOut); return ret; } /// To be documented. - public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, TagFORMATETC* pformatectIn, ref TagFORMATETC pformatetcOut) + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, FORMATETC* pformatectIn, ref FORMATETC pformatetcOut) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + fixed (FORMATETC* pformatetcOutPtr = &pformatetcOut) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOutPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOutPtr); } return ret; } /// To be documented. - public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, ref TagFORMATETC pformatectIn, TagFORMATETC* pformatetcOut) + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, ref FORMATETC pformatectIn, FORMATETC* pformatetcOut) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + fixed (FORMATETC* pformatectInPtr = &pformatectIn) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOut); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOut); } return ret; } /// To be documented. - public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, ref TagFORMATETC pformatectIn, ref TagFORMATETC pformatetcOut) + public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, ref FORMATETC pformatectIn, ref FORMATETC pformatetcOut) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + fixed (FORMATETC* pformatectInPtr = &pformatectIn) { - fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + fixed (FORMATETC* pformatetcOutPtr = &pformatetcOut) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOutPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOutPtr); } } return ret; } /// To be documented. - public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int SetData(this ComPtr thisVtbl, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmedium, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmedium, fRelease); return ret; } /// To be documented. - public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int SetData(this ComPtr thisVtbl, FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmediumPtr, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmediumPtr, fRelease); } return ret; } /// To be documented. - public static unsafe int SetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int SetData(this ComPtr thisVtbl, ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmedium, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmedium, fRelease); } return ret; } /// To be documented. - public static int SetData(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + public static int SetData(this ComPtr thisVtbl, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmediumPtr, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmediumPtr, fRelease); } } return ret; @@ -319,40 +319,40 @@ public static unsafe int EnumFormatEtc(this ComPtr thisVtbl, uint d } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnection); return ret; } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnectionPtr); } return ret; } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnection); } return ret; } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; @@ -360,66 +360,66 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnectionPtr); } } return ret; } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, ref FORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnection); } return ret; } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, ref FORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnectionPtr); } } return ret; } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, ref FORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnection); } } return ret; } /// To be documented. - public static int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + public static int DAdvise(this ComPtr thisVtbl, ref FORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnectionPtr); } } } @@ -482,7 +482,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC* pformatetcIn, Span pmedium) + public static unsafe int GetData(this ComPtr thisVtbl, FORMATETC* pformatetcIn, Span pmedium) { var @this = thisVtbl.Handle; // SpanOverloader @@ -490,7 +490,7 @@ public static unsafe int GetData(this ComPtr thisVtbl, TagFORMATETC } /// To be documented. - public static unsafe int GetData(this ComPtr thisVtbl, Span pformatetcIn, TagSTGMEDIUM* pmedium) + public static unsafe int GetData(this ComPtr thisVtbl, Span pformatetcIn, STGMEDIUM* pmedium) { var @this = thisVtbl.Handle; // SpanOverloader @@ -498,7 +498,7 @@ public static unsafe int GetData(this ComPtr thisVtbl, SpanTo be documented. - public static int GetData(this ComPtr thisVtbl, Span pformatetcIn, Span pmedium) + public static int GetData(this ComPtr thisVtbl, Span pformatetcIn, Span pmedium) { var @this = thisVtbl.Handle; // SpanOverloader @@ -506,7 +506,7 @@ public static int GetData(this ComPtr thisVtbl, Span } /// To be documented. - public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMATETC* pformatetc, Span pmedium) + public static unsafe int GetDataHere(this ComPtr thisVtbl, FORMATETC* pformatetc, Span pmedium) { var @this = thisVtbl.Handle; // SpanOverloader @@ -514,7 +514,7 @@ public static unsafe int GetDataHere(this ComPtr thisVtbl, TagFORMA } /// To be documented. - public static unsafe int GetDataHere(this ComPtr thisVtbl, Span pformatetc, TagSTGMEDIUM* pmedium) + public static unsafe int GetDataHere(this ComPtr thisVtbl, Span pformatetc, STGMEDIUM* pmedium) { var @this = thisVtbl.Handle; // SpanOverloader @@ -522,7 +522,7 @@ public static unsafe int GetDataHere(this ComPtr thisVtbl, SpanTo be documented. - public static int GetDataHere(this ComPtr thisVtbl, Span pformatetc, Span pmedium) + public static int GetDataHere(this ComPtr thisVtbl, Span pformatetc, Span pmedium) { var @this = thisVtbl.Handle; // SpanOverloader @@ -530,7 +530,7 @@ public static int GetDataHere(this ComPtr thisVtbl, SpanTo be documented. - public static int QueryGetData(this ComPtr thisVtbl, Span pformatetc) + public static int QueryGetData(this ComPtr thisVtbl, Span pformatetc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -538,7 +538,7 @@ public static int QueryGetData(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, TagFORMATETC* pformatectIn, Span pformatetcOut) + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, FORMATETC* pformatectIn, Span pformatetcOut) { var @this = thisVtbl.Handle; // SpanOverloader @@ -546,7 +546,7 @@ public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span pformatectIn, TagFORMATETC* pformatetcOut) + public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span pformatectIn, FORMATETC* pformatetcOut) { var @this = thisVtbl.Handle; // SpanOverloader @@ -554,7 +554,7 @@ public static unsafe int GetCanonicalFormatEtc(this ComPtr thisVtbl } /// To be documented. - public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span pformatectIn, Span pformatetcOut) + public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span pformatectIn, Span pformatetcOut) { var @this = thisVtbl.Handle; // SpanOverloader @@ -562,7 +562,7 @@ public static int GetCanonicalFormatEtc(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int SetData(this ComPtr thisVtbl, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; // SpanOverloader @@ -570,7 +570,7 @@ public static unsafe int SetData(this ComPtr thisVtbl, TagFORMATETC } /// To be documented. - public static unsafe int SetData(this ComPtr thisVtbl, Span pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int SetData(this ComPtr thisVtbl, Span pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; // SpanOverloader @@ -578,7 +578,7 @@ public static unsafe int SetData(this ComPtr thisVtbl, SpanTo be documented. - public static int SetData(this ComPtr thisVtbl, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static int SetData(this ComPtr thisVtbl, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = thisVtbl.Handle; // SpanOverloader @@ -594,7 +594,7 @@ public static int EnumFormatEtc(this ComPtr thisVtbl, uint dwD } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -602,7 +602,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORM } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, Span pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -610,7 +610,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -618,7 +618,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORM } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, Span pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, Span pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -626,7 +626,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC* pformatetc, uint advf, Span pAdvSink, Span pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, FORMATETC* pformatetc, uint advf, Span pAdvSink, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -634,7 +634,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, TagFORMATETC } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -642,7 +642,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int DAdvise(this ComPtr thisVtbl, ref FORMATETC pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -650,7 +650,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, ref Tag } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, IAdviseSink* pAdvSink, Span pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, IAdviseSink* pAdvSink, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -658,7 +658,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, SpanTo be documented. - public static int DAdvise(this ComPtr thisVtbl, ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int DAdvise(this ComPtr thisVtbl, ref FORMATETC pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -666,7 +666,7 @@ public static int DAdvise(this ComPtr thisVtbl, ref TagFORMATE } /// To be documented. - public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, Span pAdvSink, uint* pdwConnection) + public static unsafe int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, Span pAdvSink, uint* pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader @@ -674,7 +674,7 @@ public static unsafe int DAdvise(this ComPtr thisVtbl, SpanTo be documented. - public static int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, Span pAdvSink, Span pdwConnection) + public static int DAdvise(this ComPtr thisVtbl, Span pformatetc, uint advf, Span pAdvSink, Span pdwConnection) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs index c099f38f2c..97c3ed96cb 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumFORMATETCVtblExtensions.gen.cs @@ -85,48 +85,48 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, FORMATETC* rgelt, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, FORMATETC* rgelt, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref FORMATETC rgelt, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* rgeltPtr = &rgelt) + fixed (FORMATETC* rgeltPtr = &rgelt) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); } return ret; } /// To be documented. - public static int Next(this ComPtr thisVtbl, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) + public static int Next(this ComPtr thisVtbl, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagFORMATETC* rgeltPtr = &rgelt) + fixed (FORMATETC* rgeltPtr = &rgelt) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); } } return ret; @@ -197,7 +197,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Sp } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, FORMATETC* rgelt, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -205,7 +205,7 @@ public static unsafe int Next(this ComPtr thisVtbl, uint celt, T } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -213,7 +213,7 @@ public static unsafe int Next(this ComPtr thisVtbl, uint celt, S } /// To be documented. - public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs index 9861d5c09e..02cf02c278 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/EnumSTATDATAVtblExtensions.gen.cs @@ -85,48 +85,48 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATDATA* rgelt, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATDATA* rgelt, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); } return ret; } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, ref STATDATA rgelt, uint* pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagSTATDATA* rgeltPtr = &rgelt) + fixed (STATDATA* rgeltPtr = &rgelt) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); } return ret; } /// To be documented. - public static int Next(this ComPtr thisVtbl, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) + public static int Next(this ComPtr thisVtbl, uint celt, ref STATDATA rgelt, ref uint pceltFetched) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagSTATDATA* rgeltPtr = &rgelt) + fixed (STATDATA* rgeltPtr = &rgelt) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); } } return ret; @@ -197,7 +197,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Spa } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, STATDATA* rgelt, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -205,7 +205,7 @@ public static unsafe int Next(this ComPtr thisVtbl, uint celt, Ta } /// To be documented. - public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int Next(this ComPtr thisVtbl, uint celt, Span rgelt, uint* pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader @@ -213,7 +213,7 @@ public static unsafe int Next(this ComPtr thisVtbl, uint celt, Sp } /// To be documented. - public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) + public static int Next(this ComPtr thisVtbl, uint celt, Span rgelt, Span pceltFetched) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/FORMATETC.gen.cs similarity index 92% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/FORMATETC.gen.cs index ad5310e036..20d6db3bae 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagFORMATETC.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/FORMATETC.gen.cs @@ -17,12 +17,12 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagFORMATETC")] - public unsafe partial struct TagFORMATETC + public unsafe partial struct FORMATETC { - public TagFORMATETC + public FORMATETC ( ushort? cfFormat = null, - TagDVTARGETDEVICE* ptd = null, + DVTargetDevice* ptd = null, uint? dwAspect = null, int? lindex = null, uint? tymed = null @@ -63,7 +63,7 @@ public TagFORMATETC [NativeName("Type", "DVTARGETDEVICE *")] [NativeName("Type.Name", "DVTARGETDEVICE *")] [NativeName("Name", "ptd")] - public TagDVTARGETDEVICE* Ptd; + public DVTargetDevice* Ptd; [NativeName("Type", "DWORD")] [NativeName("Type.Name", "DWORD")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs index 8941d26d92..bd69851f55 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/FlagStgmedium.gen.cs @@ -23,7 +23,7 @@ public FlagStgmedium ( int? contextFlags = null, int? fPassOwnership = null, - TagSTGMEDIUM? stgmed = null + STGMEDIUM? stgmed = null ) : this() { if (contextFlags is not null) @@ -56,6 +56,6 @@ public FlagStgmedium [NativeName("Type", "STGMEDIUM")] [NativeName("Type.Name", "STGMEDIUM")] [NativeName("Name", "Stgmed")] - public TagSTGMEDIUM Stgmed; + public STGMEDIUM Stgmed; } } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/GlobalOptionsVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/GlobalOptionsVtblExtensions.gen.cs index 4edabd2763..af0ce420b9 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/GlobalOptionsVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/GlobalOptionsVtblExtensions.gen.cs @@ -85,31 +85,31 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static int Set(this ComPtr thisVtbl, TagGLOBALOPTPROPERTIES dwProperty, nuint dwValue) + public static int Set(this ComPtr thisVtbl, GlobalOptProperties dwProperty, nuint dwValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwProperty, dwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwProperty, dwValue); return ret; } /// To be documented. - public static unsafe int Query(this ComPtr thisVtbl, TagGLOBALOPTPROPERTIES dwProperty, nuint* pdwValue) + public static unsafe int Query(this ComPtr thisVtbl, GlobalOptProperties dwProperty, nuint* pdwValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValue); return ret; } /// To be documented. - public static int Query(this ComPtr thisVtbl, TagGLOBALOPTPROPERTIES dwProperty, ref nuint pdwValue) + public static int Query(this ComPtr thisVtbl, GlobalOptProperties dwProperty, ref nuint pdwValue) { var @this = thisVtbl.Handle; int ret = default; fixed (nuint* pdwValuePtr = &pdwValue) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValuePtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValuePtr); } return ret; } @@ -140,7 +140,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Sp } /// To be documented. - public static int Query(this ComPtr thisVtbl, TagGLOBALOPTPROPERTIES dwProperty, Span pdwValue) + public static int Query(this ComPtr thisVtbl, GlobalOptProperties dwProperty, Span pdwValue) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs index defebb3af9..499e6c2887 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink.gen.cs @@ -111,41 +111,41 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void OnDataChange(FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly unsafe void OnDataChange(FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public readonly unsafe void OnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void OnDataChange(ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public readonly void OnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly void OnDataChange(ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = (IAdviseSink*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs index 437246d37c..834d1d78da 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IAdviseSink2.gen.cs @@ -114,41 +114,41 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void OnDataChange(FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmed); } /// To be documented. - public readonly unsafe void OnDataChange(TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly unsafe void OnDataChange(FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) { var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetc, pStgmedPtr); } } /// To be documented. - public readonly unsafe void OnDataChange(ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) + public readonly unsafe void OnDataChange(ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) { var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmed); } } /// To be documented. - public readonly void OnDataChange(ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) + public readonly void OnDataChange(ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) { var @this = (IAdviseSink2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); - fixed (TagFORMATETC* pFormatetcPtr = &pFormatetc) + fixed (FORMATETC* pFormatetcPtr = &pFormatetc) { - fixed (TagSTGMEDIUM* pStgmedPtr = &pStgmed) + fixed (STGMEDIUM* pStgmedPtr = &pStgmed) { - ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); + ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pFormatetcPtr, pStgmedPtr); } } } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs index 0c3052fe82..e0d00a0a03 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IBindCtx.gen.cs @@ -162,43 +162,43 @@ public readonly int ReleaseBoundObjects() } /// To be documented. - public readonly unsafe int SetBindOptions(TagBINDOPTS* pbindopts) + public readonly unsafe int SetBindOptions(BindOpts* pbindopts) { var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindopts); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindopts); return ret; } /// To be documented. - public readonly int SetBindOptions(ref TagBINDOPTS pbindopts) + public readonly int SetBindOptions(ref BindOpts pbindopts) { var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + fixed (BindOpts* pbindoptsPtr = &pbindopts) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindoptsPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pbindoptsPtr); } return ret; } /// To be documented. - public readonly unsafe int GetBindOptions(TagBINDOPTS* pbindopts) + public readonly unsafe int GetBindOptions(BindOpts* pbindopts) { var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindopts); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindopts); return ret; } /// To be documented. - public readonly int GetBindOptions(ref TagBINDOPTS pbindopts) + public readonly int GetBindOptions(ref BindOpts pbindopts) { var @this = (IBindCtx*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagBINDOPTS* pbindoptsPtr = &pbindopts) + fixed (BindOpts* pbindoptsPtr = &pbindopts) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindoptsPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pbindoptsPtr); } return ret; } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs index e648022145..50c3dda6e2 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataAdviseHolder.gen.cs @@ -111,40 +111,40 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnection); return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvise, pdwConnectionPtr); } return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnection); } return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -152,66 +152,66 @@ public readonly unsafe int Advise(IDataObject* pDataObject, TagFORMATETC* pFetc, { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetc, advf, pAdvisePtr, pdwConnectionPtr); } } return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnection); } return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvise, pdwConnectionPtr); } } return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnection); } } return ret; } /// To be documented. - public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(IDataObject* pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObject, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); } } } @@ -219,19 +219,19 @@ public readonly unsafe int Advise(IDataObject* pDataObject, ref TagFORMATETC pFe } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnection); } return ret; } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -239,14 +239,14 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFe { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvise, pdwConnectionPtr); } } return ret; } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -254,14 +254,14 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFe { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnection); } } return ret; } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -271,7 +271,7 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFe { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetc, advf, pAdvisePtr, pdwConnectionPtr); } } } @@ -279,32 +279,32 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFe } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnection); } } return ret; } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, IAdviseSink* pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvise, pdwConnectionPtr); } } } @@ -312,17 +312,17 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) + public readonly unsafe int Advise(ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnection); } } } @@ -330,19 +330,19 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC } /// To be documented. - public readonly int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) + public readonly int Advise(ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IDataObject* pDataObjectPtr = &pDataObject) { - fixed (TagFORMATETC* pFetcPtr = &pFetc) + fixed (FORMATETC* pFetcPtr = &pFetc) { fixed (IAdviseSink* pAdvisePtr = &pAdvise) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pDataObjectPtr, pFetcPtr, advf, pAdvisePtr, pdwConnectionPtr); } } } @@ -411,7 +411,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ComPtr pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -419,7 +419,7 @@ public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATET } /// To be documented. - public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ComPtr pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -427,7 +427,7 @@ public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATET } /// To be documented. - public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ComPtr pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -435,7 +435,7 @@ public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pF } /// To be documented. - public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ComPtr pDataObject, FORMATETC* pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -443,7 +443,7 @@ public readonly unsafe int Advise(ComPtr pDataObject, TagFORMATETC* pF } /// To be documented. - public readonly unsafe int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -451,7 +451,7 @@ public readonly unsafe int Advise(ComPtr pDataObject, ref TagFORM } /// To be documented. - public readonly int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int Advise(ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -459,7 +459,7 @@ public readonly int Advise(ComPtr pDataObject, ref TagFORMATETC p } /// To be documented. - public readonly unsafe int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -467,7 +467,7 @@ public readonly unsafe int Advise(ComPtr pDataObject, ref TagFORMATETC } /// To be documented. - public readonly int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Advise(ComPtr pDataObject, ref FORMATETC pFetc, uint advf, ref IAdviseSink pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -475,7 +475,7 @@ public readonly int Advise(ComPtr pDataObject, ref TagFORMATETC pFetc, } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -483,7 +483,7 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ref IDataObject pDataObject, FORMATETC* pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -491,7 +491,7 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, TagFORMATETC } /// To be documented. - public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Advise(ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -499,7 +499,7 @@ public readonly unsafe int Advise(ref IDataObject pDataObject, ref TagFORMA } /// To be documented. - public readonly int Advise(ref IDataObject pDataObject, ref TagFORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Advise(ref IDataObject pDataObject, ref FORMATETC pFetc, uint advf, ComPtr pAdvise, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataAdviseHolder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs index 2713eab0a5..e7ba6cc4bb 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IDataObject.gen.cs @@ -111,213 +111,213 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetData(TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) + public readonly unsafe int GetData(FORMATETC* pformatetcIn, STGMEDIUM* pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmedium); return ret; } /// To be documented. - public readonly unsafe int GetData(TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium) + public readonly unsafe int GetData(FORMATETC* pformatetcIn, ref STGMEDIUM pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcIn, pmediumPtr); } return ret; } /// To be documented. - public readonly unsafe int GetData(ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium) + public readonly unsafe int GetData(ref FORMATETC pformatetcIn, STGMEDIUM* pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + fixed (FORMATETC* pformatetcInPtr = &pformatetcIn) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmedium); } return ret; } /// To be documented. - public readonly int GetData(ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium) + public readonly int GetData(ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcInPtr = &pformatetcIn) + fixed (FORMATETC* pformatetcInPtr = &pformatetcIn) { - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pformatetcInPtr, pmediumPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetDataHere(TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) + public readonly unsafe int GetDataHere(FORMATETC* pformatetc, STGMEDIUM* pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmedium); return ret; } /// To be documented. - public readonly unsafe int GetDataHere(TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium) + public readonly unsafe int GetDataHere(FORMATETC* pformatetc, ref STGMEDIUM pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetc, pmediumPtr); } return ret; } /// To be documented. - public readonly unsafe int GetDataHere(ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium) + public readonly unsafe int GetDataHere(ref FORMATETC pformatetc, STGMEDIUM* pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmedium); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmedium); } return ret; } /// To be documented. - public readonly int GetDataHere(ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium) + public readonly int GetDataHere(ref FORMATETC pformatetc, ref STGMEDIUM pmedium) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmediumPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pformatetcPtr, pmediumPtr); } } return ret; } /// To be documented. - public readonly unsafe int QueryGetData(TagFORMATETC* pformatetc) + public readonly unsafe int QueryGetData(FORMATETC* pformatetc) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetc); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetc); return ret; } /// To be documented. - public readonly int QueryGetData(ref TagFORMATETC pformatetc) + public readonly int QueryGetData(ref FORMATETC pformatetc) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetcPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[5])(@this, pformatetcPtr); } return ret; } /// To be documented. - public readonly unsafe int GetCanonicalFormatEtc(TagFORMATETC* pformatectIn, TagFORMATETC* pformatetcOut) + public readonly unsafe int GetCanonicalFormatEtc(FORMATETC* pformatectIn, FORMATETC* pformatetcOut) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOut); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOut); return ret; } /// To be documented. - public readonly unsafe int GetCanonicalFormatEtc(TagFORMATETC* pformatectIn, ref TagFORMATETC pformatetcOut) + public readonly unsafe int GetCanonicalFormatEtc(FORMATETC* pformatectIn, ref FORMATETC pformatetcOut) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + fixed (FORMATETC* pformatetcOutPtr = &pformatetcOut) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOutPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectIn, pformatetcOutPtr); } return ret; } /// To be documented. - public readonly unsafe int GetCanonicalFormatEtc(ref TagFORMATETC pformatectIn, TagFORMATETC* pformatetcOut) + public readonly unsafe int GetCanonicalFormatEtc(ref FORMATETC pformatectIn, FORMATETC* pformatetcOut) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + fixed (FORMATETC* pformatectInPtr = &pformatectIn) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOut); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOut); } return ret; } /// To be documented. - public readonly int GetCanonicalFormatEtc(ref TagFORMATETC pformatectIn, ref TagFORMATETC pformatetcOut) + public readonly int GetCanonicalFormatEtc(ref FORMATETC pformatectIn, ref FORMATETC pformatetcOut) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatectInPtr = &pformatectIn) + fixed (FORMATETC* pformatectInPtr = &pformatectIn) { - fixed (TagFORMATETC* pformatetcOutPtr = &pformatetcOut) + fixed (FORMATETC* pformatetcOutPtr = &pformatetcOut) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOutPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[6])(@this, pformatectInPtr, pformatetcOutPtr); } } return ret; } /// To be documented. - public readonly unsafe int SetData(TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public readonly unsafe int SetData(FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmedium, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmedium, fRelease); return ret; } /// To be documented. - public readonly unsafe int SetData(TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + public readonly unsafe int SetData(FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmediumPtr, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetc, pmediumPtr, fRelease); } return ret; } /// To be documented. - public readonly unsafe int SetData(ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public readonly unsafe int SetData(ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmedium, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmedium, fRelease); } return ret; } /// To be documented. - public readonly int SetData(ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) + public readonly int SetData(ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - fixed (TagSTGMEDIUM* pmediumPtr = &pmedium) + fixed (STGMEDIUM* pmediumPtr = &pmedium) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmediumPtr, fRelease); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, pformatetcPtr, pmediumPtr, fRelease); } } return ret; @@ -345,40 +345,40 @@ public readonly unsafe int EnumFormatEtc(uint dwDirection, ref IEnumFORMATETC* p } /// To be documented. - public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + public readonly unsafe int DAdvise(FORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnection); return ret; } /// To be documented. - public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + public readonly unsafe int DAdvise(FORMATETC* pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSink, pdwConnectionPtr); } return ret; } /// To be documented. - public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + public readonly unsafe int DAdvise(FORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnection); } return ret; } /// To be documented. - public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + public readonly unsafe int DAdvise(FORMATETC* pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -386,66 +386,66 @@ public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ref IAdv { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetc, advf, pAdvSinkPtr, pdwConnectionPtr); } } return ret; } /// To be documented. - public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) + public readonly unsafe int DAdvise(ref FORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, uint* pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnection); } return ret; } /// To be documented. - public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) + public readonly unsafe int DAdvise(ref FORMATETC pformatetc, uint advf, IAdviseSink* pAdvSink, ref uint pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSink, pdwConnectionPtr); } } return ret; } /// To be documented. - public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) + public readonly unsafe int DAdvise(ref FORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, uint* pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnection); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnection); } } return ret; } /// To be documented. - public readonly int DAdvise(ref TagFORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) + public readonly int DAdvise(ref FORMATETC pformatetc, uint advf, ref IAdviseSink pAdvSink, ref uint pdwConnection) { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* pformatetcPtr = &pformatetc) + fixed (FORMATETC* pformatetcPtr = &pformatetc) { fixed (IAdviseSink* pAdvSinkPtr = &pAdvSink) { fixed (uint* pdwConnectionPtr = &pdwConnection) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnectionPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[9])(@this, pformatetcPtr, advf, pAdvSinkPtr, pdwConnectionPtr); } } } @@ -500,7 +500,7 @@ public readonly int EnumFormatEtc(uint dwDirection, ref ComPtr ppenumF } /// To be documented. - public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int DAdvise(FORMATETC* pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -508,7 +508,7 @@ public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, Com } /// To be documented. - public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int DAdvise(FORMATETC* pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -516,7 +516,7 @@ public readonly unsafe int DAdvise(TagFORMATETC* pformatetc, uint advf, Com } /// To be documented. - public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int DAdvise(ref FORMATETC pformatetc, uint advf, ComPtr pAdvSink, uint* pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -524,7 +524,7 @@ public readonly unsafe int DAdvise(ref TagFORMATETC pformatetc, uint advf, } /// To be documented. - public readonly int DAdvise(ref TagFORMATETC pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int DAdvise(ref FORMATETC pformatetc, uint advf, ComPtr pAdvSink, ref uint pdwConnection) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IDataObject*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs index 61e606981c..72645f2dfd 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumFORMATETC.gen.cs @@ -111,48 +111,48 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Next(uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + public readonly unsafe int Next(uint celt, FORMATETC* rgelt, uint* pceltFetched) { var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) + public readonly unsafe int Next(uint celt, FORMATETC* rgelt, ref uint pceltFetched) { var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) + public readonly unsafe int Next(uint celt, ref FORMATETC rgelt, uint* pceltFetched) { var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* rgeltPtr = &rgelt) + fixed (FORMATETC* rgeltPtr = &rgelt) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); } return ret; } /// To be documented. - public readonly int Next(uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) + public readonly int Next(uint celt, ref FORMATETC rgelt, ref uint pceltFetched) { var @this = (IEnumFORMATETC*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagFORMATETC* rgeltPtr = &rgelt) + fixed (FORMATETC* rgeltPtr = &rgelt) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); } } return ret; diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs index cff14c9291..cd62403b8d 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IEnumSTATDATA.gen.cs @@ -111,48 +111,48 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Next(uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + public readonly unsafe int Next(uint celt, STATDATA* rgelt, uint* pceltFetched) { var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetched); return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) + public readonly unsafe int Next(uint celt, STATDATA* rgelt, ref uint pceltFetched) { var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgelt, pceltFetchedPtr); } return ret; } /// To be documented. - public readonly unsafe int Next(uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) + public readonly unsafe int Next(uint celt, ref STATDATA rgelt, uint* pceltFetched) { var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagSTATDATA* rgeltPtr = &rgelt) + fixed (STATDATA* rgeltPtr = &rgelt) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetched); } return ret; } /// To be documented. - public readonly int Next(uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) + public readonly int Next(uint celt, ref STATDATA rgelt, ref uint pceltFetched) { var @this = (IEnumSTATDATA*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagSTATDATA* rgeltPtr = &rgelt) + fixed (STATDATA* rgeltPtr = &rgelt) { fixed (uint* pceltFetchedPtr = &pceltFetched) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, celt, rgeltPtr, pceltFetchedPtr); } } return ret; diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IGlobalOptions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IGlobalOptions.gen.cs index 4e13fd557c..1c30cd6f1c 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IGlobalOptions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IGlobalOptions.gen.cs @@ -111,31 +111,31 @@ public readonly uint Release() } /// To be documented. - public readonly int Set(TagGLOBALOPTPROPERTIES dwProperty, nuint dwValue) + public readonly int Set(GlobalOptProperties dwProperty, nuint dwValue) { var @this = (IGlobalOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwProperty, dwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwProperty, dwValue); return ret; } /// To be documented. - public readonly unsafe int Query(TagGLOBALOPTPROPERTIES dwProperty, nuint* pdwValue) + public readonly unsafe int Query(GlobalOptProperties dwProperty, nuint* pdwValue) { var @this = (IGlobalOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValue); return ret; } /// To be documented. - public readonly int Query(TagGLOBALOPTPROPERTIES dwProperty, ref nuint pdwValue) + public readonly int Query(GlobalOptProperties dwProperty, ref nuint pdwValue) { var @this = (IGlobalOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (nuint* pdwValuePtr = &pdwValue) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValuePtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, dwProperty, pdwValuePtr); } return ret; } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs index a2421b60b1..8a6a87ef03 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ILayoutStorage.gen.cs @@ -111,22 +111,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int LayoutScript(TagStorageLayout* pStorageLayout, uint nEntries, uint glfInterleavedFlag) + public readonly unsafe int LayoutScript(StorageLayout* pStorageLayout, uint nEntries, uint glfInterleavedFlag) { var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayout, nEntries, glfInterleavedFlag); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayout, nEntries, glfInterleavedFlag); return ret; } /// To be documented. - public readonly int LayoutScript(ref TagStorageLayout pStorageLayout, uint nEntries, uint glfInterleavedFlag) + public readonly int LayoutScript(ref StorageLayout pStorageLayout, uint nEntries, uint glfInterleavedFlag) { var @this = (ILayoutStorage*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (TagStorageLayout* pStorageLayoutPtr = &pStorageLayout) + fixed (StorageLayout* pStorageLayoutPtr = &pStorageLayout) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayoutPtr, nEntries, glfInterleavedFlag); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayoutPtr, nEntries, glfInterleavedFlag); } return ret; } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs index 9f33d18003..15e15880c5 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IMessageFilter.gen.cs @@ -111,48 +111,48 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe uint HandleInComingCall(uint dwCallType, void* htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) + public readonly unsafe uint HandleInComingCall(uint dwCallType, void* htaskCaller, uint dwTickCount, InterfaceInfo* lpInterfaceInfo) { var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); uint ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); return ret; } /// To be documented. - public readonly unsafe uint HandleInComingCall(uint dwCallType, void* htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) + public readonly unsafe uint HandleInComingCall(uint dwCallType, void* htaskCaller, uint dwTickCount, ref InterfaceInfo lpInterfaceInfo) { var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); uint ret = default; - fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + fixed (InterfaceInfo* lpInterfaceInfoPtr = &lpInterfaceInfo) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfoPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfoPtr); } return ret; } /// To be documented. - public readonly unsafe uint HandleInComingCall(uint dwCallType, ref T0 htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) where T0 : unmanaged + public readonly unsafe uint HandleInComingCall(uint dwCallType, ref T0 htaskCaller, uint dwTickCount, InterfaceInfo* lpInterfaceInfo) where T0 : unmanaged { var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); uint ret = default; fixed (void* htaskCallerPtr = &htaskCaller) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfo); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfo); } return ret; } /// To be documented. - public readonly uint HandleInComingCall(uint dwCallType, ref T0 htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) where T0 : unmanaged + public readonly uint HandleInComingCall(uint dwCallType, ref T0 htaskCaller, uint dwTickCount, ref InterfaceInfo lpInterfaceInfo) where T0 : unmanaged { var @this = (IMessageFilter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); uint ret = default; fixed (void* htaskCallerPtr = &htaskCaller) { - fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + fixed (InterfaceInfo* lpInterfaceInfoPtr = &lpInterfaceInfo) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfoPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfoPtr); } } return ret; diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/IRpcOptions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRpcOptions.gen.cs index c0ee267b63..2ce9e7b5e4 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/IRpcOptions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/IRpcOptions.gen.cs @@ -111,61 +111,61 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Set(Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) + public readonly unsafe int Set(Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, nuint dwValue) { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrx, dwProperty, dwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrx, dwProperty, dwValue); return ret; } /// To be documented. - public readonly int Set(ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) + public readonly int Set(ref Silk.NET.Core.Native.IUnknown pPrx, RPCOptProperties dwProperty, nuint dwValue) { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Native.IUnknown* pPrxPtr = &pPrx) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrxPtr, dwProperty, dwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrxPtr, dwProperty, dwValue); } return ret; } /// To be documented. - public readonly unsafe int Query(Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) + public readonly unsafe int Query(Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, nuint* pdwValue) { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValue); return ret; } /// To be documented. - public readonly unsafe int Query(Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, ref nuint pdwValue) + public readonly unsafe int Query(Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, ref nuint pdwValue) { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (nuint* pdwValuePtr = &pdwValue) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValuePtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValuePtr); } return ret; } /// To be documented. - public readonly unsafe int Query(ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) + public readonly unsafe int Query(ref Silk.NET.Core.Native.IUnknown pPrx, RPCOptProperties dwProperty, nuint* pdwValue) { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Native.IUnknown* pPrxPtr = &pPrx) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValue); } return ret; } /// To be documented. - public readonly int Query(ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPERTIES dwProperty, ref nuint pdwValue) + public readonly int Query(ref Silk.NET.Core.Native.IUnknown pPrx, RPCOptProperties dwProperty, ref nuint pdwValue) { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -173,7 +173,7 @@ public readonly int Query(ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPE { fixed (nuint* pdwValuePtr = &pdwValue) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValuePtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValuePtr); } } return ret; @@ -189,7 +189,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly int Set(ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Set(ComPtr pPrx, RPCOptProperties dwProperty, nuint dwValue) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -197,7 +197,7 @@ public readonly int Set(ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, n } /// To be documented. - public readonly unsafe int Query(ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Query(ComPtr pPrx, RPCOptProperties dwProperty, nuint* pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -205,7 +205,7 @@ public readonly unsafe int Query(ComPtr pPrx, TagRPCOPTPROPERTIES dwPr } /// To be documented. - public readonly int Query(ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, ref nuint pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Query(ComPtr pPrx, RPCOptProperties dwProperty, ref nuint pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IRpcOptions*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs index ddc38c3233..d063ef4abe 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/ISurrogateService.gen.cs @@ -219,22 +219,22 @@ public readonly int Init(ref Guid rguidProcessID, ref IProcessLock pProcessLock, } /// To be documented. - public readonly unsafe int ApplicationLaunch(Guid* rguidApplID, TagApplicationType appType) + public readonly unsafe int ApplicationLaunch(Guid* rguidApplID, ApplicationType appType) { var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplID, appType); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplID, appType); return ret; } /// To be documented. - public readonly int ApplicationLaunch(ref Guid rguidApplID, TagApplicationType appType) + public readonly int ApplicationLaunch(ref Guid rguidApplID, ApplicationType appType) { var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* rguidApplIDPtr = &rguidApplID) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplIDPtr, appType); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplIDPtr, appType); } return ret; } @@ -270,11 +270,11 @@ public readonly int CatalogRefresh(uint ulReserved) } /// To be documented. - public readonly int ProcessShutdown(TagShutdownType shutdownType) + public readonly int ProcessShutdown(ShutdownType shutdownType) { var @this = (ISurrogateService*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, shutdownType); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, shutdownType); return ret; } diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/InterfaceInfo.gen.cs similarity index 94% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/InterfaceInfo.gen.cs index 8add3f56d1..e38515be33 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagINTERFACEINFO.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/InterfaceInfo.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagINTERFACEINFO")] - public unsafe partial struct TagINTERFACEINFO + public unsafe partial struct InterfaceInfo { - public TagINTERFACEINFO + public InterfaceInfo ( Silk.NET.Core.Native.IUnknown* pUnk = null, Guid? iid = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs index c2380dc60e..b3f4e86a12 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/LayoutStorageVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int LayoutScript(this ComPtr thisVtbl, TagStorageLayout* pStorageLayout, uint nEntries, uint glfInterleavedFlag) + public static unsafe int LayoutScript(this ComPtr thisVtbl, StorageLayout* pStorageLayout, uint nEntries, uint glfInterleavedFlag) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayout, nEntries, glfInterleavedFlag); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayout, nEntries, glfInterleavedFlag); return ret; } /// To be documented. - public static int LayoutScript(this ComPtr thisVtbl, ref TagStorageLayout pStorageLayout, uint nEntries, uint glfInterleavedFlag) + public static int LayoutScript(this ComPtr thisVtbl, ref StorageLayout pStorageLayout, uint nEntries, uint glfInterleavedFlag) { var @this = thisVtbl.Handle; int ret = default; - fixed (TagStorageLayout* pStorageLayoutPtr = &pStorageLayout) + fixed (StorageLayout* pStorageLayoutPtr = &pStorageLayout) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayoutPtr, nEntries, glfInterleavedFlag); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pStorageLayoutPtr, nEntries, glfInterleavedFlag); } return ret; } @@ -202,7 +202,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Sp } /// To be documented. - public static int LayoutScript(this ComPtr thisVtbl, Span pStorageLayout, uint nEntries, uint glfInterleavedFlag) + public static int LayoutScript(this ComPtr thisVtbl, Span pStorageLayout, uint nEntries, uint glfInterleavedFlag) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs index 04e2b68dde..14fc73880c 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/MessageFilterVtblExtensions.gen.cs @@ -85,48 +85,48 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, InterfaceInfo* lpInterfaceInfo) { var @this = thisVtbl.Handle; uint ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfo); return ret; } /// To be documented. - public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, ref InterfaceInfo lpInterfaceInfo) { var @this = thisVtbl.Handle; uint ret = default; - fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + fixed (InterfaceInfo* lpInterfaceInfoPtr = &lpInterfaceInfo) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfoPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCaller, dwTickCount, lpInterfaceInfoPtr); } return ret; } /// To be documented. - public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, ref T0 htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) where T0 : unmanaged + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, ref T0 htaskCaller, uint dwTickCount, InterfaceInfo* lpInterfaceInfo) where T0 : unmanaged { var @this = thisVtbl.Handle; uint ret = default; fixed (void* htaskCallerPtr = &htaskCaller) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfo); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfo); } return ret; } /// To be documented. - public static uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, ref T0 htaskCaller, uint dwTickCount, ref TagINTERFACEINFO lpInterfaceInfo) where T0 : unmanaged + public static uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, ref T0 htaskCaller, uint dwTickCount, ref InterfaceInfo lpInterfaceInfo) where T0 : unmanaged { var @this = thisVtbl.Handle; uint ret = default; fixed (void* htaskCallerPtr = &htaskCaller) { - fixed (TagINTERFACEINFO* lpInterfaceInfoPtr = &lpInterfaceInfo) + fixed (InterfaceInfo* lpInterfaceInfoPtr = &lpInterfaceInfo) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfoPtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, dwCallType, htaskCallerPtr, dwTickCount, lpInterfaceInfoPtr); } } return ret; @@ -200,7 +200,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Sp } /// To be documented. - public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, Span lpInterfaceInfo) + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, void* htaskCaller, uint dwTickCount, Span lpInterfaceInfo) { var @this = thisVtbl.Handle; // SpanOverloader @@ -208,7 +208,7 @@ public static unsafe uint HandleInComingCall(this ComPtr thisVtb } /// To be documented. - public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, Span htaskCaller, uint dwTickCount, TagINTERFACEINFO* lpInterfaceInfo) where T0 : unmanaged + public static unsafe uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, Span htaskCaller, uint dwTickCount, InterfaceInfo* lpInterfaceInfo) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -216,7 +216,7 @@ public static unsafe uint HandleInComingCall(this ComPtr thi } /// To be documented. - public static uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, Span htaskCaller, uint dwTickCount, Span lpInterfaceInfo) where T0 : unmanaged + public static uint HandleInComingCall(this ComPtr thisVtbl, uint dwCallType, Span htaskCaller, uint dwTickCount, Span lpInterfaceInfo) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RemSNB.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/RemSNB.gen.cs index 3da2687a55..4990f0a650 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSNB.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RemSNB.gen.cs @@ -18,9 +18,9 @@ namespace Silk.NET.Core.Win32Extras { [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] [NativeName("Name", "tagRemSNB")] - public unsafe partial struct TagRemSNB + public unsafe partial struct RemSNB { - public TagRemSNB + public RemSNB ( uint? ulCntStr = null, uint? ulCntChar = null diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RemSTGMEDIUM.gen.cs similarity index 96% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/RemSTGMEDIUM.gen.cs index dc63dd651a..7e712d51bb 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagRemSTGMEDIUM.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RemSTGMEDIUM.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagRemSTGMEDIUM")] - public unsafe partial struct TagRemSTGMEDIUM + public unsafe partial struct RemSTGMEDIUM { - public TagRemSTGMEDIUM + public RemSTGMEDIUM ( uint? tymed = null, uint? dwHandleType = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/RpcOptionsVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/RpcOptionsVtblExtensions.gen.cs index 2e1a5a98aa..c0b9a230aa 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/RpcOptionsVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/RpcOptionsVtblExtensions.gen.cs @@ -85,61 +85,61 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Set(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) + public static unsafe int Set(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, nuint dwValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrx, dwProperty, dwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrx, dwProperty, dwValue); return ret; } /// To be documented. - public static int Set(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) + public static int Set(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pPrx, RPCOptProperties dwProperty, nuint dwValue) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Native.IUnknown* pPrxPtr = &pPrx) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrxPtr, dwProperty, dwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[3])(@this, pPrxPtr, dwProperty, dwValue); } return ret; } /// To be documented. - public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) + public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, nuint* pdwValue) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValue); return ret; } /// To be documented. - public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, ref nuint pdwValue) + public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, ref nuint pdwValue) { var @this = thisVtbl.Handle; int ret = default; fixed (nuint* pdwValuePtr = &pdwValue) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValuePtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrx, dwProperty, pdwValuePtr); } return ret; } /// To be documented. - public static unsafe int Query(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) + public static unsafe int Query(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pPrx, RPCOptProperties dwProperty, nuint* pdwValue) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Native.IUnknown* pPrxPtr = &pPrx) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValue); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValue); } return ret; } /// To be documented. - public static int Query(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pPrx, TagRPCOPTPROPERTIES dwProperty, ref nuint pdwValue) + public static int Query(this ComPtr thisVtbl, ref Silk.NET.Core.Native.IUnknown pPrx, RPCOptProperties dwProperty, ref nuint pdwValue) { var @this = thisVtbl.Handle; int ret = default; @@ -147,7 +147,7 @@ public static int Query(this ComPtr thisVtbl, ref Silk.NET.Core.Nat { fixed (nuint* pdwValuePtr = &pdwValue) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValuePtr); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, pPrxPtr, dwProperty, pdwValuePtr); } } return ret; @@ -179,7 +179,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Span< } /// To be documented. - public static int Set(this ComPtr thisVtbl, ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Set(this ComPtr thisVtbl, ComPtr pPrx, RPCOptProperties dwProperty, nuint dwValue) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -187,7 +187,7 @@ public static int Set(this ComPtr thisVtbl, ComPtr pPrx, } /// To be documented. - public static int Set(this ComPtr thisVtbl, Span pPrx, TagRPCOPTPROPERTIES dwProperty, nuint dwValue) + public static int Set(this ComPtr thisVtbl, Span pPrx, RPCOptProperties dwProperty, nuint dwValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -195,7 +195,7 @@ public static int Set(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int Query(this ComPtr thisVtbl, ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Query(this ComPtr thisVtbl, ComPtr pPrx, RPCOptProperties dwProperty, nuint* pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -203,7 +203,7 @@ public static unsafe int Query(this ComPtr thisVtbl, ComPtrTo be documented. - public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, TagRPCOPTPROPERTIES dwProperty, Span pdwValue) + public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core.Native.IUnknown* pPrx, RPCOptProperties dwProperty, Span pdwValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -211,7 +211,7 @@ public static unsafe int Query(this ComPtr thisVtbl, Silk.NET.Core. } /// To be documented. - public static int Query(this ComPtr thisVtbl, ComPtr pPrx, TagRPCOPTPROPERTIES dwProperty, ref nuint pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Query(this ComPtr thisVtbl, ComPtr pPrx, RPCOptProperties dwProperty, ref nuint pdwValue) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -219,7 +219,7 @@ public static int Query(this ComPtr thisVtbl, ComPtr pPrx } /// To be documented. - public static unsafe int Query(this ComPtr thisVtbl, Span pPrx, TagRPCOPTPROPERTIES dwProperty, nuint* pdwValue) + public static unsafe int Query(this ComPtr thisVtbl, Span pPrx, RPCOptProperties dwProperty, nuint* pdwValue) { var @this = thisVtbl.Handle; // SpanOverloader @@ -227,7 +227,7 @@ public static unsafe int Query(this ComPtr thisVtbl, SpanTo be documented. - public static int Query(this ComPtr thisVtbl, Span pPrx, TagRPCOPTPROPERTIES dwProperty, Span pdwValue) + public static int Query(this ComPtr thisVtbl, Span pPrx, RPCOptProperties dwProperty, Span pdwValue) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/STATDATA.gen.cs similarity index 91% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/STATDATA.gen.cs index 35b12088dc..be2d920b6d 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTATDATA.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/STATDATA.gen.cs @@ -17,11 +17,11 @@ namespace Silk.NET.Core.Win32Extras { [NativeName("Name", "tagSTATDATA")] - public unsafe partial struct TagSTATDATA + public unsafe partial struct STATDATA { - public TagSTATDATA + public STATDATA ( - TagFORMATETC? formatetc = null, + FORMATETC? formatetc = null, uint? advf = null, IAdviseSink* pAdvSink = null, uint? dwConnection = null @@ -52,7 +52,7 @@ public TagSTATDATA [NativeName("Type", "FORMATETC")] [NativeName("Type.Name", "FORMATETC")] [NativeName("Name", "formatetc")] - public TagFORMATETC Formatetc; + public FORMATETC Formatetc; [NativeName("Type", "DWORD")] [NativeName("Type.Name", "DWORD")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/STGMEDIUM.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/STGMEDIUM.gen.cs index 78b896e096..e48dfbc972 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUM.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/STGMEDIUM.gen.cs @@ -18,12 +18,12 @@ namespace Silk.NET.Core.Win32Extras { [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] [NativeName("Name", "tagSTGMEDIUM")] - public unsafe partial struct TagSTGMEDIUM + public unsafe partial struct STGMEDIUM { - public TagSTGMEDIUM + public STGMEDIUM ( uint? tymed = null, - TagSTGMEDIUMUnion? anonymous = null, + STGMEDIUMUnion? anonymous = null, Silk.NET.Core.Native.IUnknown* pUnkForRelease = null, void* hBitmap = null, void* hMetaFilePict = null, @@ -94,7 +94,7 @@ public TagSTGMEDIUM [NativeName("Type", "")] [NativeName("Type.Name", "__AnonymousRecord_objidl_L12046_C36")] [NativeName("Name", "anonymous1")] - public TagSTGMEDIUMUnion Anonymous; + public STGMEDIUMUnion Anonymous; [NativeName("Type", "IUnknown *")] [NativeName("Type.Name", "IUnknown *")] diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/STGMEDIUMUnion.gen.cs similarity index 97% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/STGMEDIUMUnion.gen.cs index a582aa2b20..84ac47c638 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagSTGMEDIUMUnion.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/STGMEDIUMUnion.gen.cs @@ -18,9 +18,9 @@ namespace Silk.NET.Core.Win32Extras { [StructLayout(LayoutKind.Explicit, CharSet = CharSet.Unicode)] [NativeName("Name", "__AnonymousRecord_objidl_L12046_C36")] - public unsafe partial struct TagSTGMEDIUMUnion + public unsafe partial struct STGMEDIUMUnion { - public TagSTGMEDIUMUnion + public STGMEDIUMUnion ( void* hBitmap = null, void* hMetaFilePict = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/StorageLayout.gen.cs similarity index 95% rename from src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs rename to src/Core/Silk.NET.Core.Win32Extras/Structs/StorageLayout.gen.cs index e749c09b73..59b161a76b 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/TagStorageLayout.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/StorageLayout.gen.cs @@ -18,9 +18,9 @@ namespace Silk.NET.Core.Win32Extras { [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)] [NativeName("Name", "tagStorageLayout")] - public unsafe partial struct TagStorageLayout + public unsafe partial struct StorageLayout { - public TagStorageLayout + public StorageLayout ( uint? layoutType = null, char* pwcsElementName = null, diff --git a/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs index 08a5a7c1fc..d7345c6924 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Structs/SurrogateServiceVtblExtensions.gen.cs @@ -193,22 +193,22 @@ public static int Init(this ComPtr thisVtbl, ref Guid rguidPr } /// To be documented. - public static unsafe int ApplicationLaunch(this ComPtr thisVtbl, Guid* rguidApplID, TagApplicationType appType) + public static unsafe int ApplicationLaunch(this ComPtr thisVtbl, Guid* rguidApplID, ApplicationType appType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplID, appType); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplID, appType); return ret; } /// To be documented. - public static int ApplicationLaunch(this ComPtr thisVtbl, ref Guid rguidApplID, TagApplicationType appType) + public static int ApplicationLaunch(this ComPtr thisVtbl, ref Guid rguidApplID, ApplicationType appType) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* rguidApplIDPtr = &rguidApplID) { - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplIDPtr, appType); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[4])(@this, rguidApplIDPtr, appType); } return ret; } @@ -244,11 +244,11 @@ public static int CatalogRefresh(this ComPtr thisVtbl, uint u } /// To be documented. - public static int ProcessShutdown(this ComPtr thisVtbl, TagShutdownType shutdownType) + public static int ProcessShutdown(this ComPtr thisVtbl, ShutdownType shutdownType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, shutdownType); + ret = ((delegate* unmanaged[Cdecl])@this->LpVtbl[7])(@this, shutdownType); return ret; } @@ -366,7 +366,7 @@ public static int Init(this ComPtr thisVtbl, Span rguid } /// To be documented. - public static int ApplicationLaunch(this ComPtr thisVtbl, Span rguidApplID, TagApplicationType appType) + public static int ApplicationLaunch(this ComPtr thisVtbl, Span rguidApplID, ApplicationType appType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs index 401165c7e6..25d68f3e09 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/Windows.gen.cs @@ -18353,22 +18353,22 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] - public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(IBindCtx* This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(IBindCtx* This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] - public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS2 pbindopts); + public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(IBindCtx* This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] - public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxRemoteSetBindOptionsProxy(ref IBindCtx This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteSetBindOptions_Proxy")] - public partial int IBindCtxRemoteSetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); + public partial int IBindCtxRemoteSetBindOptionsProxy(ref IBindCtx This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 9311, Column 17 in objidl.h")] @@ -18453,22 +18453,22 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] - public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(IBindCtx* This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(IBindCtx* This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] - public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS2 pbindopts); + public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(IBindCtx* This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] - public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxRemoteGetBindOptionsProxy(ref IBindCtx This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_RemoteGetBindOptions_Proxy")] - public partial int IBindCtxRemoteGetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); + public partial int IBindCtxRemoteGetBindOptionsProxy(ref IBindCtx This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 9323, Column 17 in objidl.h")] @@ -20203,42 +20203,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, ref FORMATETC rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(IEnumFORMATETC* This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, FORMATETC* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, FORMATETC* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, ref FORMATETC rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_RemoteNext_Proxy")] - public partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + public partial int IEnumFORMATETCRemoteNextProxy(ref IEnumFORMATETC This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11726, Column 17 in objidl.h")] @@ -20323,42 +20323,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, STATDATA* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, STATDATA* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, ref STATDATA rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(IEnumSTATDATA* This, uint celt, ref STATDATA rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, STATDATA* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, STATDATA* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, ref STATDATA rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_RemoteNext_Proxy")] - public partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + public partial int IEnumSTATDATARemoteNextProxy(ref IEnumSTATDATA This, uint celt, ref STATDATA rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 11887, Column 17 in objidl.h")] @@ -20443,42 +20443,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(IAdviseSink* This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_RemoteOnDataChange_Proxy")] - public partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public partial int IAdviseSinkRemoteOnDataChangeProxy(ref IAdviseSink This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12248, Column 17 in objidl.h")] @@ -20933,42 +20933,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(AsyncIAdviseSink* This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_RemoteOnDataChange_Proxy")] - public partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public partial int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref AsyncIAdviseSink This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 12487, Column 17 in objidl.h")] @@ -22163,42 +22163,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(IDataObject* This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetData_Proxy")] - public partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public partial int IDataObjectRemoteGetDataProxy(ref IDataObject This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13178, Column 17 in objidl.h")] @@ -22283,42 +22283,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(IDataObject* This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteGetDataHere_Proxy")] - public partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public partial int IDataObjectRemoteGetDataHereProxy(ref IDataObject This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 13191, Column 17 in objidl.h")] @@ -22403,42 +22403,42 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(IDataObject* This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_RemoteSetData_Proxy")] - public partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public partial int IDataObjectRemoteSetDataProxy(ref IDataObject This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 13205, Column 17 in objidl.h")] @@ -22803,306 +22803,306 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] - public unsafe partial uint ASYNCSTGMEDIUMUserSize(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint ASYNCSTGMEDIUMUserSize(uint* arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] - public unsafe partial uint ASYNCSTGMEDIUMUserSize(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + public unsafe partial uint ASYNCSTGMEDIUMUserSize(uint* arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] - public unsafe partial uint ASYNCSTGMEDIUMUserSize(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint ASYNCSTGMEDIUMUserSize(ref uint arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize")] - public partial uint ASYNCSTGMEDIUMUserSize(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + public partial uint ASYNCSTGMEDIUMUserSize(ref uint arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal")] - public partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal")] - public partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] - public unsafe partial void ASYNCSTGMEDIUMUserFree(uint* arg0, TagSTGMEDIUM* arg1); + public unsafe partial void ASYNCSTGMEDIUMUserFree(uint* arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] - public unsafe partial void ASYNCSTGMEDIUMUserFree(uint* arg0, ref TagSTGMEDIUM arg1); + public unsafe partial void ASYNCSTGMEDIUMUserFree(uint* arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] - public unsafe partial void ASYNCSTGMEDIUMUserFree(ref uint arg0, TagSTGMEDIUM* arg1); + public unsafe partial void ASYNCSTGMEDIUMUserFree(ref uint arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree")] - public partial void ASYNCSTGMEDIUMUserFree(ref uint arg0, ref TagSTGMEDIUM arg1); + public partial void ASYNCSTGMEDIUMUserFree(ref uint arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15468, Column 39 in objidl.h")] @@ -24931,610 +24931,610 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] - public unsafe partial uint STGMEDIUMUserSize(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint STGMEDIUMUserSize(uint* arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] - public unsafe partial uint STGMEDIUMUserSize(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + public unsafe partial uint STGMEDIUMUserSize(uint* arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] - public unsafe partial uint STGMEDIUMUserSize(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint STGMEDIUMUserSize(ref uint arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize")] - public partial uint STGMEDIUMUserSize(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + public partial uint STGMEDIUMUserSize(ref uint arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public partial string STGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserMarshalS(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal")] - public partial string STGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public partial string STGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserUnmarshalS(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal")] - public partial string STGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] - public unsafe partial void STGMEDIUMUserFree(uint* arg0, TagSTGMEDIUM* arg1); + public unsafe partial void STGMEDIUMUserFree(uint* arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] - public unsafe partial void STGMEDIUMUserFree(uint* arg0, ref TagSTGMEDIUM arg1); + public unsafe partial void STGMEDIUMUserFree(uint* arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] - public unsafe partial void STGMEDIUMUserFree(ref uint arg0, TagSTGMEDIUM* arg1); + public unsafe partial void STGMEDIUMUserFree(ref uint arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree")] - public partial void STGMEDIUMUserFree(ref uint arg0, ref TagSTGMEDIUM arg1); + public partial void STGMEDIUMUserFree(ref uint arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] - public unsafe partial uint ASYNCSTGMEDIUMUserSize64(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint ASYNCSTGMEDIUMUserSize64(uint* arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] - public unsafe partial uint ASYNCSTGMEDIUMUserSize64(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + public unsafe partial uint ASYNCSTGMEDIUMUserSize64(uint* arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] - public unsafe partial uint ASYNCSTGMEDIUMUserSize64(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint ASYNCSTGMEDIUMUserSize64(ref uint arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserSize64")] - public partial uint ASYNCSTGMEDIUMUserSize64(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + public partial uint ASYNCSTGMEDIUMUserSize64(ref uint arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserMarshal64")] - public partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* ASYNCSTGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserUnmarshal64")] - public partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string ASYNCSTGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] - public unsafe partial void ASYNCSTGMEDIUMUserFree64(uint* arg0, TagSTGMEDIUM* arg1); + public unsafe partial void ASYNCSTGMEDIUMUserFree64(uint* arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] - public unsafe partial void ASYNCSTGMEDIUMUserFree64(uint* arg0, ref TagSTGMEDIUM arg1); + public unsafe partial void ASYNCSTGMEDIUMUserFree64(uint* arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] - public unsafe partial void ASYNCSTGMEDIUMUserFree64(ref uint arg0, TagSTGMEDIUM* arg1); + public unsafe partial void ASYNCSTGMEDIUMUserFree64(ref uint arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] [NativeApi(EntryPoint = "ASYNC_STGMEDIUM_UserFree64")] - public partial void ASYNCSTGMEDIUMUserFree64(ref uint arg0, ref TagSTGMEDIUM arg1); + public partial void ASYNCSTGMEDIUMUserFree64(ref uint arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15508, Column 39 in objidl.h")] @@ -27363,386 +27363,386 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] - public unsafe partial uint STGMEDIUMUserSize64(uint* arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint STGMEDIUMUserSize64(uint* arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] - public unsafe partial uint STGMEDIUMUserSize64(uint* arg0, uint arg1, ref TagSTGMEDIUM arg2); + public unsafe partial uint STGMEDIUMUserSize64(uint* arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] - public unsafe partial uint STGMEDIUMUserSize64(ref uint arg0, uint arg1, TagSTGMEDIUM* arg2); + public unsafe partial uint STGMEDIUMUserSize64(ref uint arg0, uint arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserSize64")] - public partial uint STGMEDIUMUserSize64(ref uint arg0, uint arg1, ref TagSTGMEDIUM arg2); + public partial uint STGMEDIUMUserSize64(ref uint arg0, uint arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public partial string STGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserMarshal64S(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserMarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserMarshal64")] - public partial string STGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserMarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref TagSTGMEDIUM arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, byte* arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, ref byte arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2); + public unsafe partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public unsafe partial byte* STGMEDIUMUserUnmarshal64(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "STGMEDIUM_UserUnmarshal64")] - public partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref TagSTGMEDIUM arg2); + public partial string STGMEDIUMUserUnmarshal64S(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref STGMEDIUM arg2); /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] - public unsafe partial void STGMEDIUMUserFree64(uint* arg0, TagSTGMEDIUM* arg1); + public unsafe partial void STGMEDIUMUserFree64(uint* arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] - public unsafe partial void STGMEDIUMUserFree64(uint* arg0, ref TagSTGMEDIUM arg1); + public unsafe partial void STGMEDIUMUserFree64(uint* arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] - public unsafe partial void STGMEDIUMUserFree64(ref uint arg0, TagSTGMEDIUM* arg1); + public unsafe partial void STGMEDIUMUserFree64(ref uint arg0, STGMEDIUM* arg1); /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] [NativeApi(EntryPoint = "STGMEDIUM_UserFree64")] - public partial void STGMEDIUMUserFree64(ref uint arg0, ref TagSTGMEDIUM arg1); + public partial void STGMEDIUMUserFree64(ref uint arg0, ref STGMEDIUM arg1); /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] - public unsafe partial int IBindCtxSetBindOptionsProxy(IBindCtx* This, TagBINDOPTS* pbindopts); + public unsafe partial int IBindCtxSetBindOptionsProxy(IBindCtx* This, BindOpts* pbindopts); /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] - public unsafe partial int IBindCtxSetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS pbindopts); + public unsafe partial int IBindCtxSetBindOptionsProxy(IBindCtx* This, ref BindOpts pbindopts); /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] - public unsafe partial int IBindCtxSetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS* pbindopts); + public unsafe partial int IBindCtxSetBindOptionsProxy(ref IBindCtx This, BindOpts* pbindopts); /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Proxy")] - public partial int IBindCtxSetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS pbindopts); + public partial int IBindCtxSetBindOptionsProxy(ref IBindCtx This, ref BindOpts pbindopts); /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] - public unsafe partial int IBindCtxSetBindOptionsStub(IBindCtx* This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxSetBindOptionsStub(IBindCtx* This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] - public unsafe partial int IBindCtxSetBindOptionsStub(IBindCtx* This, ref TagBINDOPTS2 pbindopts); + public unsafe partial int IBindCtxSetBindOptionsStub(IBindCtx* This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] - public unsafe partial int IBindCtxSetBindOptionsStub(ref IBindCtx This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxSetBindOptionsStub(ref IBindCtx This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_SetBindOptions_Stub")] - public partial int IBindCtxSetBindOptionsStub(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); + public partial int IBindCtxSetBindOptionsStub(ref IBindCtx This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] - public unsafe partial int IBindCtxGetBindOptionsProxy(IBindCtx* This, TagBINDOPTS* pbindopts); + public unsafe partial int IBindCtxGetBindOptionsProxy(IBindCtx* This, BindOpts* pbindopts); /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] - public unsafe partial int IBindCtxGetBindOptionsProxy(IBindCtx* This, ref TagBINDOPTS pbindopts); + public unsafe partial int IBindCtxGetBindOptionsProxy(IBindCtx* This, ref BindOpts pbindopts); /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] - public unsafe partial int IBindCtxGetBindOptionsProxy(ref IBindCtx This, TagBINDOPTS* pbindopts); + public unsafe partial int IBindCtxGetBindOptionsProxy(ref IBindCtx This, BindOpts* pbindopts); /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Proxy")] - public partial int IBindCtxGetBindOptionsProxy(ref IBindCtx This, ref TagBINDOPTS pbindopts); + public partial int IBindCtxGetBindOptionsProxy(ref IBindCtx This, ref BindOpts pbindopts); /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] - public unsafe partial int IBindCtxGetBindOptionsStub(IBindCtx* This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxGetBindOptionsStub(IBindCtx* This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] - public unsafe partial int IBindCtxGetBindOptionsStub(IBindCtx* This, ref TagBINDOPTS2 pbindopts); + public unsafe partial int IBindCtxGetBindOptionsStub(IBindCtx* This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] - public unsafe partial int IBindCtxGetBindOptionsStub(ref IBindCtx This, TagBINDOPTS2* pbindopts); + public unsafe partial int IBindCtxGetBindOptionsStub(ref IBindCtx This, BindOpts2* pbindopts); /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IBindCtx_GetBindOptions_Stub")] - public partial int IBindCtxGetBindOptionsStub(ref IBindCtx This, ref TagBINDOPTS2 pbindopts); + public partial int IBindCtxGetBindOptionsStub(ref IBindCtx This, ref BindOpts2 pbindopts); /// To be documented. [NativeName("Src", "Line 15658, Column 41 in objidl.h")] @@ -29327,242 +29327,242 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, ref FORMATETC rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(IEnumFORMATETC* This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, FORMATETC* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, FORMATETC* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, ref FORMATETC rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Proxy")] - public partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + public partial int IEnumFORMATETCNextProxy(ref IEnumFORMATETC This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, ref FORMATETC rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(IEnumFORMATETC* This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, FORMATETC* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, FORMATETC* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched); + public unsafe partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, ref FORMATETC rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumFORMATETC_Next_Stub")] - public partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched); + public partial int IEnumFORMATETCNextStub(ref IEnumFORMATETC This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, STATDATA* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, STATDATA* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, ref STATDATA rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(IEnumSTATDATA* This, uint celt, ref STATDATA rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, STATDATA* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, STATDATA* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, ref STATDATA rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Proxy")] - public partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + public partial int IEnumSTATDATANextProxy(ref IEnumSTATDATA This, uint celt, ref STATDATA rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, STATDATA* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, STATDATA* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, ref STATDATA rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(IEnumSTATDATA* This, uint celt, ref STATDATA rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, STATDATA* rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, STATDATA* rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched); + public unsafe partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, ref STATDATA rgelt, uint* pceltFetched); /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IEnumSTATDATA_Next_Stub")] - public partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched); + public partial int IEnumSTATDATANextStub(ref IEnumSTATDATA This, uint celt, ref STATDATA rgelt, ref uint pceltFetched); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(IAdviseSink* This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Proxy")] - public partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public partial void IAdviseSinkOnDataChangeProxy(ref IAdviseSink This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(IAdviseSink* This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IAdviseSink_OnDataChange_Stub")] - public partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public partial int IAdviseSinkOnDataChangeStub(ref IAdviseSink This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15869, Column 38 in objidl.h")] @@ -29667,82 +29667,82 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(AsyncIAdviseSink* This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Proxy")] - public partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public partial void AsyncIAdviseSinkBeginOnDataChangeProxy(ref AsyncIAdviseSink This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(AsyncIAdviseSink* This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed); + public unsafe partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed); /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] [NativeApi(EntryPoint = "AsyncIAdviseSink_Begin_OnDataChange_Stub")] - public partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed); + public partial int AsyncIAdviseSinkBeginOnDataChangeStub(ref AsyncIAdviseSink This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed); /// To be documented. [NativeName("Src", "Line 15917, Column 38 in objidl.h")] @@ -30047,242 +30047,242 @@ public unsafe partial class Windows : NativeAPI /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, FORMATETC* pformatetcIn, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium); + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, FORMATETC* pformatetcIn, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, ref FORMATETC pformatetcIn, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium); + public unsafe partial int IDataObjectGetDataProxy(IDataObject* This, ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, FORMATETC* pformatetcIn, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium); + public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, FORMATETC* pformatetcIn, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataProxy(ref IDataObject This, ref FORMATETC pformatetcIn, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Proxy")] - public partial int IDataObjectGetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium); + public partial int IDataObjectGetDataProxy(ref IDataObject This, ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(IDataObject* This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(IDataObject* This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(IDataObject* This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(IDataObject* This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(IDataObject* This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataStub(ref IDataObject This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetData_Stub")] - public partial int IDataObjectGetDataStub(ref IDataObject This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium); + public partial int IDataObjectGetDataStub(ref IDataObject This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, FORMATETC* pformatetc, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, FORMATETC* pformatetc, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, ref FORMATETC pformatetc, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(IDataObject* This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, FORMATETC* pformatetc, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, FORMATETC* pformatetc, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium); + public unsafe partial int IDataObjectGetDataHereProxy(ref IDataObject This, ref FORMATETC pformatetc, STGMEDIUM* pmedium); /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Proxy")] - public partial int IDataObjectGetDataHereProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium); + public partial int IDataObjectGetDataHereProxy(ref IDataObject This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(IDataObject* This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium); + public unsafe partial int IDataObjectGetDataHereStub(ref IDataObject This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_GetDataHere_Stub")] - public partial int IDataObjectGetDataHereStub(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium); + public partial int IDataObjectGetDataHereStub(ref IDataObject This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(IDataObject* This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataProxy(ref IDataObject This, ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Proxy")] - public partial int IDataObjectSetDataProxy(ref IDataObject This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); + public partial int IDataObjectSetDataProxy(ref IDataObject This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(IDataObject* This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(IDataObject* This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(IDataObject* This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(IDataObject* This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(IDataObject* This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); + public unsafe partial int IDataObjectSetDataStub(ref IDataObject This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] [NativeApi(EntryPoint = "IDataObject_SetData_Stub")] - public partial int IDataObjectSetDataStub(ref IDataObject This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); + public partial int IDataObjectSetDataStub(ref IDataObject This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease); /// To be documented. [NativeName("Src", "Line 16055, Column 41 in objidl.h")] @@ -35139,7 +35139,7 @@ public unsafe int IStreamCopyToStub(ref Silk.NET.Core.Win32Extras.IStream T /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); @@ -35147,7 +35147,7 @@ public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, TagBI /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxRemoteSetBindOptionsProxy(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxRemoteSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); @@ -35251,7 +35251,7 @@ public unsafe void IBindCtxRemoteSetBindOptionsStub(ref IRpcStubBuffer This /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); @@ -35259,7 +35259,7 @@ public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, TagBI /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxRemoteGetBindOptionsProxy(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxRemoteGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); @@ -37483,7 +37483,7 @@ public unsafe void ILockBytesRemoteWriteAtStub(ref IRpcStubBuffer This, Com /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); @@ -37491,7 +37491,7 @@ public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); @@ -37499,7 +37499,7 @@ public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); @@ -37507,7 +37507,7 @@ public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCRemoteNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCRemoteNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); @@ -37611,7 +37611,7 @@ public unsafe void IEnumFORMATETCRemoteNextStub(ref IRpcStubBuffer This, Co /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); @@ -37619,7 +37619,7 @@ public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); @@ -37627,7 +37627,7 @@ public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); @@ -37635,7 +37635,7 @@ public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATARemoteNextProxy(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATARemoteNextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); @@ -37739,7 +37739,7 @@ public unsafe void IEnumSTATDATARemoteNextStub(ref IRpcStubBuffer This, Com /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); @@ -37747,7 +37747,7 @@ public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, TagF /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); @@ -37755,7 +37755,7 @@ public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, TagF /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); @@ -37763,7 +37763,7 @@ public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkRemoteOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); @@ -38299,7 +38299,7 @@ public unsafe void IAdviseSinkRemoteOnCloseStub(ref IRpcStubBuffer This, Co /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); @@ -38307,7 +38307,7 @@ public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); @@ -38315,7 +38315,7 @@ public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); @@ -38323,7 +38323,7 @@ public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginRemoteOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); @@ -39723,7 +39723,7 @@ public unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(ref IRp /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); @@ -39731,7 +39731,7 @@ public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, TagFORMAT /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); @@ -39739,7 +39739,7 @@ public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, TagFORMAT /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); @@ -39747,7 +39747,7 @@ public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref TagFO /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); @@ -39851,7 +39851,7 @@ public unsafe void IDataObjectRemoteGetDataStub(ref IRpcStubBuffer This, Co /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pRemoteMedium); @@ -39859,7 +39859,7 @@ public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, TagFO /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); @@ -39867,7 +39867,7 @@ public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, TagFO /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); @@ -39875,7 +39875,7 @@ public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref T /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); @@ -39979,7 +39979,7 @@ public unsafe void IDataObjectRemoteGetDataHereStub(ref IRpcStubBuffer This /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); @@ -39987,7 +39987,7 @@ public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, TagFORMAT /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); @@ -39995,7 +39995,7 @@ public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, TagFORMAT /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); @@ -40003,7 +40003,7 @@ public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref TagFO /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectRemoteSetDataProxy(ComPtr This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectRemoteSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); @@ -40395,7 +40395,7 @@ public unsafe void IFillLockBytesRemoteFillAtStub(ref IRpcStubBuffer This, /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, TagBINDOPTS* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, BindOpts* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); @@ -40403,7 +40403,7 @@ public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, TagBINDOPTS /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, ref TagBINDOPTS pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, ref BindOpts pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxSetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); @@ -40411,7 +40411,7 @@ public unsafe int IBindCtxSetBindOptionsProxy(ComPtr This, ref TagBIND /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); @@ -40419,7 +40419,7 @@ public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, TagBINDOPTS2 /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxSetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); @@ -40427,7 +40427,7 @@ public unsafe int IBindCtxSetBindOptionsStub(ComPtr This, ref TagBINDO /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, TagBINDOPTS* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, BindOpts* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, pbindopts); @@ -40435,7 +40435,7 @@ public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, TagBINDOPTS /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, ref TagBINDOPTS pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, ref BindOpts pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxGetBindOptionsProxy((IBindCtx*) This.Handle, ref pbindopts); @@ -40443,7 +40443,7 @@ public unsafe int IBindCtxGetBindOptionsProxy(ComPtr This, ref TagBIND /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, TagBINDOPTS2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, BindOpts2* pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, pbindopts); @@ -40451,7 +40451,7 @@ public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, TagBINDOPTS2 /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, ref TagBINDOPTS2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IBindCtxGetBindOptionsStub(ComPtr This, ref BindOpts2 pbindopts) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IBindCtxGetBindOptionsStub((IBindCtx*) This.Handle, ref pbindopts); @@ -42635,7 +42635,7 @@ public unsafe int ILockBytesWriteAtStub(ComPtr This, ulong ulOffset, [ /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); @@ -42643,7 +42643,7 @@ public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, TagF /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); @@ -42651,7 +42651,7 @@ public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, TagF /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); @@ -42659,7 +42659,7 @@ public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextProxy((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); @@ -42667,7 +42667,7 @@ public unsafe int IEnumFORMATETCNextProxy(ComPtr This, uint celt, ref /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, FORMATETC* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, pceltFetched); @@ -42675,7 +42675,7 @@ public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, TagFO /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, TagFORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, FORMATETC* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, rgelt, ref pceltFetched); @@ -42683,7 +42683,7 @@ public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, TagFO /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref TagFORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref FORMATETC rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, pceltFetched); @@ -42691,7 +42691,7 @@ public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref T /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref TagFORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref FORMATETC rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumFORMATETCNextStub((IEnumFORMATETC*) This.Handle, celt, ref rgelt, ref pceltFetched); @@ -42699,7 +42699,7 @@ public unsafe int IEnumFORMATETCNextStub(ComPtr This, uint celt, ref T /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); @@ -42707,7 +42707,7 @@ public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, TagST /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); @@ -42715,7 +42715,7 @@ public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, TagST /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); @@ -42723,7 +42723,7 @@ public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref T /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextProxy((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); @@ -42731,7 +42731,7 @@ public unsafe int IEnumSTATDATANextProxy(ComPtr This, uint celt, ref T /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, STATDATA* rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, pceltFetched); @@ -42739,7 +42739,7 @@ public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, TagSTA /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, TagSTATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, STATDATA* rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, rgelt, ref pceltFetched); @@ -42747,7 +42747,7 @@ public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, TagSTA /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref TagSTATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref STATDATA rgelt, uint* pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, pceltFetched); @@ -42755,7 +42755,7 @@ public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref Ta /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref TagSTATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref STATDATA rgelt, ref uint pceltFetched) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IEnumSTATDATANextStub((IEnumSTATDATA*) This.Handle, celt, ref rgelt, ref pceltFetched); @@ -42763,7 +42763,7 @@ public unsafe int IEnumSTATDATANextStub(ComPtr This, uint celt, ref Ta /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, pStgmed); @@ -42771,7 +42771,7 @@ public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, TagFORMAT /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); @@ -42779,7 +42779,7 @@ public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, TagFORMAT /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); @@ -42787,7 +42787,7 @@ public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref TagFO /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader IAdviseSinkOnDataChangeProxy((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); @@ -42795,7 +42795,7 @@ public unsafe void IAdviseSinkOnDataChangeProxy(ComPtr This, ref TagFO /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, pStgmed); @@ -42803,7 +42803,7 @@ public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, TagFORMATET /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, pFormatetc, ref pStgmed); @@ -42811,7 +42811,7 @@ public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, TagFORMATET /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, pStgmed); @@ -42819,7 +42819,7 @@ public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref TagFORM /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IAdviseSinkOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IAdviseSinkOnDataChangeStub((IAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); @@ -42923,7 +42923,7 @@ public unsafe int IAdviseSinkOnCloseStub(ComPtr This) where TI0 : unma /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); @@ -42931,7 +42931,7 @@ public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); @@ -42939,7 +42939,7 @@ public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); @@ -42947,7 +42947,7 @@ public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader AsyncIAdviseSinkBeginOnDataChangeProxy((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); @@ -42955,7 +42955,7 @@ public unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, pStgmed); @@ -42963,7 +42963,7 @@ public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, T /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, TagFORMATETC* pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, FORMATETC* pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, pFormatetc, ref pStgmed); @@ -42971,7 +42971,7 @@ public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, T /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, TagSTGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, STGMEDIUM* pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, pStgmed); @@ -42979,7 +42979,7 @@ public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, r /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref TagFORMATETC pFormatetc, ref TagSTGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(ComPtr This, ref FORMATETC pFormatetc, ref STGMEDIUM pStgmed) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return AsyncIAdviseSinkBeginOnDataChangeStub((AsyncIAdviseSink*) This.Handle, ref pFormatetc, ref pStgmed); @@ -43275,7 +43275,7 @@ public unsafe int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(ComPtr Th /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, pmedium); @@ -43283,7 +43283,7 @@ public unsafe int IDataObjectGetDataProxy(ComPtr This, TagFORMATETC* p /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataProxy(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataProxy((IDataObject*) This.Handle, pformatetcIn, ref pmedium); @@ -43291,7 +43291,7 @@ public unsafe int IDataObjectGetDataProxy(ComPtr This, TagFORMATETC* p /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, pmedium); @@ -43299,7 +43299,7 @@ public unsafe int IDataObjectGetDataProxy(ComPtr This, ref TagFORMATET /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataProxy(ComPtr This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataProxy(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataProxy((IDataObject*) This.Handle, ref pformatetcIn, ref pmedium); @@ -43307,7 +43307,7 @@ public unsafe int IDataObjectGetDataProxy(ComPtr This, ref TagFORMATET /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataStub(ComPtr This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, pRemoteMedium); @@ -43315,7 +43315,7 @@ public unsafe int IDataObjectGetDataStub(ComPtr This, TagFORMATETC* pf /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, TagFORMATETC* pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataStub(ComPtr This, FORMATETC* pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataStub((IDataObject*) This.Handle, pformatetcIn, ref pRemoteMedium); @@ -43323,7 +43323,7 @@ public unsafe int IDataObjectGetDataStub(ComPtr This, TagFORMATETC* pf /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, ref TagFORMATETC pformatetcIn, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataStub(ComPtr This, ref FORMATETC pformatetcIn, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, pRemoteMedium); @@ -43331,7 +43331,7 @@ public unsafe int IDataObjectGetDataStub(ComPtr This, ref TagFORMATETC /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataStub(ComPtr This, ref TagFORMATETC pformatetcIn, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataStub(ComPtr This, ref FORMATETC pformatetcIn, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataStub((IDataObject*) This.Handle, ref pformatetcIn, ref pRemoteMedium); @@ -43339,7 +43339,7 @@ public unsafe int IDataObjectGetDataStub(ComPtr This, ref TagFORMATETC /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, pmedium); @@ -43347,7 +43347,7 @@ public unsafe int IDataObjectGetDataHereProxy(ComPtr This, TagFORMATET /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, pformatetc, ref pmedium); @@ -43355,7 +43355,7 @@ public unsafe int IDataObjectGetDataHereProxy(ComPtr This, TagFORMATET /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, pmedium); @@ -43363,7 +43363,7 @@ public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref TagFORM /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium); @@ -43371,7 +43371,7 @@ public unsafe int IDataObjectGetDataHereProxy(ComPtr This, ref TagFORM /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereStub(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, pRemoteMedium); @@ -43379,7 +43379,7 @@ public unsafe int IDataObjectGetDataHereStub(ComPtr This, TagFORMATETC /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereStub(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereStub((IDataObject*) This.Handle, pformatetc, ref pRemoteMedium); @@ -43387,7 +43387,7 @@ public unsafe int IDataObjectGetDataHereStub(ComPtr This, TagFORMATETC /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, pRemoteMedium); @@ -43395,7 +43395,7 @@ public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref TagFORMA /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pRemoteMedium) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectGetDataHereStub((IDataObject*) This.Handle, ref pformatetc, ref pRemoteMedium); @@ -43403,7 +43403,7 @@ public unsafe int IDataObjectGetDataHereStub(ComPtr This, ref TagFORMA /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataProxy(ComPtr This, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); @@ -43411,7 +43411,7 @@ public unsafe int IDataObjectSetDataProxy(ComPtr This, TagFORMATETC* p /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, TagFORMATETC* pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataProxy(ComPtr This, FORMATETC* pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataProxy((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); @@ -43419,7 +43419,7 @@ public unsafe int IDataObjectSetDataProxy(ComPtr This, TagFORMATETC* p /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataProxy(ComPtr This, ref FORMATETC pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); @@ -43427,7 +43427,7 @@ public unsafe int IDataObjectSetDataProxy(ComPtr This, ref TagFORMATET /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public unsafe int IDataObjectSetDataProxy(ComPtr This, ref TagFORMATETC pformatetc, ref TagSTGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataProxy(ComPtr This, ref FORMATETC pformatetc, ref STGMEDIUM pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataProxy((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); @@ -43435,7 +43435,7 @@ public unsafe int IDataObjectSetDataProxy(ComPtr This, ref TagFORMATET /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataStub(ComPtr This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, pmedium, fRelease); @@ -43443,7 +43443,7 @@ public unsafe int IDataObjectSetDataStub(ComPtr This, TagFORMATETC* pf /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, TagFORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataStub(ComPtr This, FORMATETC* pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataStub((IDataObject*) This.Handle, pformatetc, ref pmedium, fRelease); @@ -43451,7 +43451,7 @@ public unsafe int IDataObjectSetDataStub(ComPtr This, TagFORMATETC* pf /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, ref TagFORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataStub(ComPtr This, ref FORMATETC pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, pmedium, fRelease); @@ -43459,7 +43459,7 @@ public unsafe int IDataObjectSetDataStub(ComPtr This, ref TagFORMATETC /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public unsafe int IDataObjectSetDataStub(ComPtr This, ref TagFORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IDataObjectSetDataStub(ComPtr This, ref FORMATETC pformatetc, ref FlagStgmedium pmedium, Silk.NET.Core.Bool32 fRelease) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IDataObjectSetDataStub((IDataObject*) This.Handle, ref pformatetc, ref pmedium, fRelease); diff --git a/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs b/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs index cdbc9819cb..e05636449d 100644 --- a/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs +++ b/src/Core/Silk.NET.Core.Win32Extras/WindowsOverloads.gen.cs @@ -10906,7 +10906,7 @@ public static unsafe int IStreamCopyToStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxRemoteSetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); @@ -10914,7 +10914,7 @@ public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, Span This, BindOpts2* pbindopts) { // SpanOverloader return thisApi.IBindCtxRemoteSetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); @@ -10922,7 +10922,7 @@ public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 9306, Column 43 in objidl.h")] - public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + public static unsafe int IBindCtxRemoteSetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxRemoteSetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); @@ -11050,7 +11050,7 @@ public static unsafe void IBindCtxRemoteSetBindOptionsStub(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxRemoteGetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); @@ -11058,7 +11058,7 @@ public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, Span This, BindOpts2* pbindopts) { // SpanOverloader return thisApi.IBindCtxRemoteGetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); @@ -11066,7 +11066,7 @@ public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 9318, Column 43 in objidl.h")] - public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + public static unsafe int IBindCtxRemoteGetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxRemoteGetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); @@ -13546,7 +13546,7 @@ public static unsafe void ILockBytesRemoteWriteAtStub(this Windows thisApi, Span /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -13554,7 +13554,7 @@ public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEn /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -13562,7 +13562,7 @@ public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEn /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -13570,7 +13570,7 @@ public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, IEn /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, FORMATETC* rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); @@ -13578,7 +13578,7 @@ public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, FORMATETC* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -13586,7 +13586,7 @@ public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -13594,7 +13594,7 @@ public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 11719, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCRemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCRemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -13722,7 +13722,7 @@ public static unsafe void IEnumFORMATETCRemoteNextStub(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, STATDATA* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -13730,7 +13730,7 @@ public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnu /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -13738,7 +13738,7 @@ public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnu /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -13746,7 +13746,7 @@ public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, IEnu /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, STATDATA* rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); @@ -13754,7 +13754,7 @@ public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, STATDATA* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -13762,7 +13762,7 @@ public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -13770,7 +13770,7 @@ public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span /// To be documented. [NativeName("Src", "Line 11880, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATARemoteNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATARemoteNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -13898,7 +13898,7 @@ public static unsafe void IEnumSTATDATARemoteNextStub(this Windows thisApi, Span /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); @@ -13906,7 +13906,7 @@ public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); @@ -13914,7 +13914,7 @@ public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -13922,7 +13922,7 @@ public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); @@ -13930,7 +13930,7 @@ public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); @@ -13938,7 +13938,7 @@ public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); @@ -13946,7 +13946,7 @@ public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi /// To be documented. [NativeName("Src", "Line 12242, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -14602,7 +14602,7 @@ public static unsafe void IAdviseSinkRemoteOnCloseStub(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); @@ -14610,7 +14610,7 @@ public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windo /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); @@ -14618,7 +14618,7 @@ public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windo /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -14626,7 +14626,7 @@ public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windo /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); @@ -14634,7 +14634,7 @@ public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windo /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); @@ -14642,7 +14642,7 @@ public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windo /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); @@ -14650,7 +14650,7 @@ public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windo /// To be documented. [NativeName("Src", "Line 12481, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginRemoteOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -16362,7 +16362,7 @@ public static unsafe void AsyncIAdviseSink2FinishRemoteOnLinkSrcChangeStub(this /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, FORMATETC* pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(This, pformatetcIn, ref pRemoteMedium.GetPinnableReference()); @@ -16370,7 +16370,7 @@ public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDa /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), pRemoteMedium); @@ -16378,7 +16378,7 @@ public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDa /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -16386,7 +16386,7 @@ public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, IDa /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, pRemoteMedium); @@ -16394,7 +16394,7 @@ public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, ref pRemoteMedium.GetPinnableReference()); @@ -16402,7 +16402,7 @@ public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), pRemoteMedium); @@ -16410,7 +16410,7 @@ public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13172, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -16538,7 +16538,7 @@ public static unsafe void IDataObjectRemoteGetDataStub(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, FORMATETC* pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(This, pformatetc, ref pRemoteMedium.GetPinnableReference()); @@ -16546,7 +16546,7 @@ public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), pRemoteMedium); @@ -16554,7 +16554,7 @@ public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -16562,7 +16562,7 @@ public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, pRemoteMedium); @@ -16570,7 +16570,7 @@ public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, ref pRemoteMedium.GetPinnableReference()); @@ -16578,7 +16578,7 @@ public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pRemoteMedium); @@ -16586,7 +16586,7 @@ public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13185, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectRemoteGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectRemoteGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -16714,7 +16714,7 @@ public static unsafe void IDataObjectRemoteGetDataHereStub(this Windows thisApi, /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(This, pformatetc, ref pmedium.GetPinnableReference(), fRelease); @@ -16722,7 +16722,7 @@ public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDa /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(This, ref pformatetc.GetPinnableReference(), pmedium, fRelease); @@ -16730,7 +16730,7 @@ public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDa /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); @@ -16738,7 +16738,7 @@ public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, IDa /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), pformatetc, pmedium, fRelease); @@ -16746,7 +16746,7 @@ public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference(), fRelease); @@ -16754,7 +16754,7 @@ public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium, fRelease); @@ -16762,7 +16762,7 @@ public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 13198, Column 43 in objidl.h")] - public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectRemoteSetDataProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectRemoteSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); @@ -17290,7 +17290,7 @@ public static unsafe void IFillLockBytesRemoteFillAtStub(this Windows thisApi, S /// To be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] - public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserSize(arg0, arg1, ref arg2.GetPinnableReference()); @@ -17298,7 +17298,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, uint* arg /// To be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] - public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, arg2); @@ -17306,7 +17306,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15463, Column 39 in objidl.h")] - public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -17314,7 +17314,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -17322,7 +17322,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); @@ -17330,7 +17330,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -17338,7 +17338,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -17346,7 +17346,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -17354,7 +17354,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -17362,7 +17362,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -17370,7 +17370,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -17378,7 +17378,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -17386,7 +17386,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15464, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -17394,7 +17394,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -17402,7 +17402,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); @@ -17410,7 +17410,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -17418,7 +17418,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -17426,7 +17426,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -17434,7 +17434,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -17442,7 +17442,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -17450,7 +17450,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -17458,7 +17458,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -17466,7 +17466,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15465, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -17474,7 +17474,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] - public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) + public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) { // SpanOverloader thisApi.ASYNCSTGMEDIUMUserFree(arg0, ref arg1.GetPinnableReference()); @@ -17482,7 +17482,7 @@ public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, uint* arg /// To be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] - public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, Span arg0, STGMEDIUM* arg1) { // SpanOverloader thisApi.ASYNCSTGMEDIUMUserFree(ref arg0.GetPinnableReference(), arg1); @@ -17490,7 +17490,7 @@ public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15466, Column 39 in objidl.h")] - public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) + public static unsafe void ASYNCSTGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) { // SpanOverloader thisApi.ASYNCSTGMEDIUMUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); @@ -18602,7 +18602,7 @@ public static unsafe void SNBUserFree(this Windows thisApi, Span arg0, ref /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] - public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, uint* arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserSize(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18610,7 +18610,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, uint* arg0, ui /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] - public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18618,7 +18618,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15498, Column 39 in objidl.h")] - public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) + public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18626,7 +18626,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18634,7 +18634,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); @@ -18642,7 +18642,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18650,7 +18650,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18658,7 +18658,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18666,7 +18666,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18674,7 +18674,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -18682,7 +18682,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18690,7 +18690,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18698,7 +18698,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15499, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18706,7 +18706,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18714,7 +18714,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); @@ -18722,7 +18722,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18730,7 +18730,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18738,7 +18738,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18746,7 +18746,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18754,7 +18754,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -18762,7 +18762,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18770,7 +18770,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18778,7 +18778,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15500, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18786,7 +18786,7 @@ public static unsafe uint STGMEDIUMUserSize(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] - public static unsafe void STGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) + public static unsafe void STGMEDIUMUserFree(this Windows thisApi, uint* arg0, Span arg1) { // SpanOverloader thisApi.STGMEDIUMUserFree(arg0, ref arg1.GetPinnableReference()); @@ -18794,7 +18794,7 @@ public static unsafe void STGMEDIUMUserFree(this Windows thisApi, uint* arg0, Sp /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] - public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg0, STGMEDIUM* arg1) { // SpanOverloader thisApi.STGMEDIUMUserFree(ref arg0.GetPinnableReference(), arg1); @@ -18802,7 +18802,7 @@ public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15501, Column 39 in objidl.h")] - public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) + public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg0, Span arg1) { // SpanOverloader thisApi.STGMEDIUMUserFree(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); @@ -18810,7 +18810,7 @@ public static unsafe void STGMEDIUMUserFree(this Windows thisApi, Span arg /// To be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] - public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18818,7 +18818,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, uint* a /// To be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] - public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18826,7 +18826,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15503, Column 39 in objidl.h")] - public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18834,7 +18834,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18842,7 +18842,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); @@ -18850,7 +18850,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18858,7 +18858,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18866,7 +18866,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18874,7 +18874,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18882,7 +18882,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -18890,7 +18890,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18898,7 +18898,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18906,7 +18906,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15504, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18914,7 +18914,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18922,7 +18922,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); @@ -18930,7 +18930,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18938,7 +18938,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -18946,7 +18946,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18954,7 +18954,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18962,7 +18962,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -18970,7 +18970,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -18978,7 +18978,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -18986,7 +18986,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15505, Column 29 in objidl.h")] - public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* ASYNCSTGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.ASYNCSTGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -18994,7 +18994,7 @@ public static unsafe uint ASYNCSTGMEDIUMUserSize64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] - public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) + public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) { // SpanOverloader thisApi.ASYNCSTGMEDIUMUserFree64(arg0, ref arg1.GetPinnableReference()); @@ -19002,7 +19002,7 @@ public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, uint* a /// To be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] - public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, STGMEDIUM* arg1) { // SpanOverloader thisApi.ASYNCSTGMEDIUMUserFree64(ref arg0.GetPinnableReference(), arg1); @@ -19010,7 +19010,7 @@ public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15506, Column 39 in objidl.h")] - public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) + public static unsafe void ASYNCSTGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) { // SpanOverloader thisApi.ASYNCSTGMEDIUMUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); @@ -20122,7 +20122,7 @@ public static unsafe void SNBUserFree64(this Windows thisApi, Span arg0, r /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] - public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) + public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, uint* arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserSize64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -20130,7 +20130,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, uint* arg0, /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] - public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, TagSTGMEDIUM* arg2) + public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -20138,7 +20138,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15538, Column 39 in objidl.h")] - public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) + public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span arg0, uint arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserSize64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -20146,7 +20146,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -20154,7 +20154,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), arg2); @@ -20162,7 +20162,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -20170,7 +20170,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -20178,7 +20178,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -20186,7 +20186,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -20194,7 +20194,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -20202,7 +20202,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -20210,7 +20210,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -20218,7 +20218,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15539, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserMarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserMarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -20226,7 +20226,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -20234,7 +20234,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), arg2); @@ -20242,7 +20242,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(arg0, ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -20250,7 +20250,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(arg0, arg1, ref arg2.GetPinnableReference()); @@ -20258,7 +20258,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -20266,7 +20266,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, byte* arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -20274,7 +20274,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); @@ -20282,7 +20282,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, Span arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2.GetPinnableReference()); @@ -20290,7 +20290,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, TagSTGMEDIUM* arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, STGMEDIUM* arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, arg2); @@ -20298,7 +20298,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15540, Column 29 in objidl.h")] - public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) + public static unsafe byte* STGMEDIUMUserUnmarshal64(this Windows thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, Span arg2) { // SpanOverloader return thisApi.STGMEDIUMUserUnmarshal64(ref arg0.GetPinnableReference(), arg1, ref arg2.GetPinnableReference()); @@ -20306,7 +20306,7 @@ public static unsafe uint STGMEDIUMUserSize64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] - public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) + public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, uint* arg0, Span arg1) { // SpanOverloader thisApi.STGMEDIUMUserFree64(arg0, ref arg1.GetPinnableReference()); @@ -20314,7 +20314,7 @@ public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, uint* arg0, /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] - public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span arg0, TagSTGMEDIUM* arg1) + public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span arg0, STGMEDIUM* arg1) { // SpanOverloader thisApi.STGMEDIUMUserFree64(ref arg0.GetPinnableReference(), arg1); @@ -20322,7 +20322,7 @@ public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15541, Column 39 in objidl.h")] - public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) + public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span arg0, Span arg1) { // SpanOverloader thisApi.STGMEDIUMUserFree64(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference()); @@ -20330,7 +20330,7 @@ public static unsafe void STGMEDIUMUserFree64(this Windows thisApi, Span a /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxSetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); @@ -20338,7 +20338,7 @@ public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, IBind /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS* pbindopts) + public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span This, BindOpts* pbindopts) { // SpanOverloader return thisApi.IBindCtxSetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); @@ -20346,7 +20346,7 @@ public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15638, Column 41 in objidl.h")] - public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxSetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); @@ -20354,7 +20354,7 @@ public static unsafe int IBindCtxSetBindOptionsProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, IBindCtx* This, Span pbindopts) + public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, IBindCtx* This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxSetBindOptionsStub(This, ref pbindopts.GetPinnableReference()); @@ -20362,7 +20362,7 @@ public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, IBindC /// To be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, Span This, BindOpts2* pbindopts) { // SpanOverloader return thisApi.IBindCtxSetBindOptionsStub(ref This.GetPinnableReference(), pbindopts); @@ -20370,7 +20370,7 @@ public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15644, Column 43 in objidl.h")] - public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, Span This, Span pbindopts) + public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, Span This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxSetBindOptionsStub(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); @@ -20378,7 +20378,7 @@ public static unsafe int IBindCtxSetBindOptionsStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) + public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, IBindCtx* This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxGetBindOptionsProxy(This, ref pbindopts.GetPinnableReference()); @@ -20386,7 +20386,7 @@ public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, IBind /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span This, TagBINDOPTS* pbindopts) + public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span This, BindOpts* pbindopts) { // SpanOverloader return thisApi.IBindCtxGetBindOptionsProxy(ref This.GetPinnableReference(), pbindopts); @@ -20394,7 +20394,7 @@ public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15648, Column 41 in objidl.h")] - public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) + public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxGetBindOptionsProxy(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); @@ -20402,7 +20402,7 @@ public static unsafe int IBindCtxGetBindOptionsProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, IBindCtx* This, Span pbindopts) + public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, IBindCtx* This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxGetBindOptionsStub(This, ref pbindopts.GetPinnableReference()); @@ -20410,7 +20410,7 @@ public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, IBindC /// To be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, Span This, TagBINDOPTS2* pbindopts) + public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, Span This, BindOpts2* pbindopts) { // SpanOverloader return thisApi.IBindCtxGetBindOptionsStub(ref This.GetPinnableReference(), pbindopts); @@ -20418,7 +20418,7 @@ public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15654, Column 43 in objidl.h")] - public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, Span This, Span pbindopts) + public static unsafe int IBindCtxGetBindOptionsStub(this Windows thisApi, Span This, Span pbindopts) { // SpanOverloader return thisApi.IBindCtxGetBindOptionsStub(ref This.GetPinnableReference(), ref pbindopts.GetPinnableReference()); @@ -22602,7 +22602,7 @@ public static unsafe int ILockBytesWriteAtStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22610,7 +22610,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORM /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22618,7 +22618,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORM /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22626,7 +22626,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, IEnumFORM /// To be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, FORMATETC* rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); @@ -22634,7 +22634,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, FORMATETC* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22642,7 +22642,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22650,7 +22650,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15826, Column 41 in objidl.h")] - public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22658,7 +22658,7 @@ public static unsafe int IEnumFORMATETCNextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, FORMATETC* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22666,7 +22666,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMA /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22674,7 +22674,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMA /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMATETC* This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22682,7 +22682,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, IEnumFORMA /// To be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, FORMATETC* rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); @@ -22690,7 +22690,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, TagFORMATETC* rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, FORMATETC* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22698,7 +22698,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22706,7 +22706,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15835, Column 43 in objidl.h")] - public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumFORMATETCNextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22714,7 +22714,7 @@ public static unsafe int IEnumFORMATETCNextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, STATDATA* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22722,7 +22722,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATD /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22730,7 +22730,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATD /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22738,7 +22738,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, IEnumSTATD /// To be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, STATDATA* rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); @@ -22746,7 +22746,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, STATDATA* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22754,7 +22754,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22762,7 +22762,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15841, Column 41 in objidl.h")] - public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextProxy(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22770,7 +22770,7 @@ public static unsafe int IEnumSTATDATANextProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, STATDATA* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(This, celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22778,7 +22778,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDA /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(This, celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22786,7 +22786,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDA /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDATA* This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(This, celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22794,7 +22794,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, IEnumSTATDA /// To be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, STATDATA* rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, rgelt, pceltFetched); @@ -22802,7 +22802,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, TagSTATDATA* rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, STATDATA* rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, rgelt, ref pceltFetched.GetPinnableReference()); @@ -22810,7 +22810,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, Span rgelt, uint* pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), pceltFetched); @@ -22818,7 +22818,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15850, Column 43 in objidl.h")] - public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) + public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, Span This, uint celt, Span rgelt, Span pceltFetched) { // SpanOverloader return thisApi.IEnumSTATDATANextStub(ref This.GetPinnableReference(), celt, ref rgelt.GetPinnableReference(), ref pceltFetched.GetPinnableReference()); @@ -22826,7 +22826,7 @@ public static unsafe int IEnumSTATDATANextStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); @@ -22834,7 +22834,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAd /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); @@ -22842,7 +22842,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAd /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -22850,7 +22850,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, IAd /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); @@ -22858,7 +22858,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); @@ -22866,7 +22866,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); @@ -22874,7 +22874,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 15856, Column 38 in objidl.h")] - public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) { // SpanOverloader thisApi.IAdviseSinkOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -22882,7 +22882,7 @@ public static unsafe void IAdviseSinkOnDataChangeProxy(this Windows thisApi, Spa /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(This, pFormatetc, ref pStgmed.GetPinnableReference()); @@ -22890,7 +22890,7 @@ public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdvi /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), pStgmed); @@ -22898,7 +22898,7 @@ public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdvi /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdviseSink* This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -22906,7 +22906,7 @@ public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, IAdvi /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, pStgmed); @@ -22914,7 +22914,7 @@ public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); @@ -22922,7 +22922,7 @@ public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); @@ -22930,7 +22930,7 @@ public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 15864, Column 43 in objidl.h")] - public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + public static unsafe int IAdviseSinkOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.IAdviseSinkOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -23034,7 +23034,7 @@ public static unsafe int IAdviseSinkOnCloseStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(This, pFormatetc, ref pStgmed.GetPinnableReference()); @@ -23042,7 +23042,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), pStgmed); @@ -23050,7 +23050,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -23058,7 +23058,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, pStgmed); @@ -23066,7 +23066,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); @@ -23074,7 +23074,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); @@ -23082,7 +23082,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15904, Column 38 in objidl.h")] - public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) { // SpanOverloader thisApi.AsyncIAdviseSinkBeginOnDataChangeProxy(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -23090,7 +23090,7 @@ public static unsafe void AsyncIAdviseSinkBeginOnDataChangeProxy(this Windows th /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(This, pFormatetc, ref pStgmed.GetPinnableReference()); @@ -23098,7 +23098,7 @@ public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows this /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), pStgmed); @@ -23106,7 +23106,7 @@ public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows this /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, AsyncIAdviseSink* This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(This, ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -23114,7 +23114,7 @@ public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows this /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, FORMATETC* pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, pStgmed); @@ -23122,7 +23122,7 @@ public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows this /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, TagFORMATETC* pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, FORMATETC* pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), pFormatetc, ref pStgmed.GetPinnableReference()); @@ -23130,7 +23130,7 @@ public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows this /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, TagSTGMEDIUM* pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, STGMEDIUM* pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), pStgmed); @@ -23138,7 +23138,7 @@ public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows this /// To be documented. [NativeName("Src", "Line 15912, Column 43 in objidl.h")] - public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) + public static unsafe int AsyncIAdviseSinkBeginOnDataChangeStub(this Windows thisApi, Span This, Span pFormatetc, Span pStgmed) { // SpanOverloader return thisApi.AsyncIAdviseSinkBeginOnDataChangeStub(ref This.GetPinnableReference(), ref pFormatetc.GetPinnableReference(), ref pStgmed.GetPinnableReference()); @@ -23434,7 +23434,7 @@ public static unsafe int AsyncIAdviseSink2FinishOnLinkSrcChangeStub(this Windows /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetcIn, Span pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, FORMATETC* pformatetcIn, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(This, pformatetcIn, ref pmedium.GetPinnableReference()); @@ -23442,7 +23442,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObje /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, TagSTGMEDIUM* pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, STGMEDIUM* pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), pmedium); @@ -23450,7 +23450,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObje /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(This, ref pformatetcIn.GetPinnableReference(), ref pmedium.GetPinnableReference()); @@ -23458,7 +23458,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, IDataObje /// To be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetcIn, STGMEDIUM* pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, pmedium); @@ -23466,7 +23466,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, Span pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetcIn, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), pformatetcIn, ref pmedium.GetPinnableReference()); @@ -23474,7 +23474,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, TagSTGMEDIUM* pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, STGMEDIUM* pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), pmedium); @@ -23482,7 +23482,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16014, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, Span pmedium) + public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, Span This, Span pformatetcIn, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataProxy(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), ref pmedium.GetPinnableReference()); @@ -23490,7 +23490,7 @@ public static unsafe int IDataObjectGetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, FORMATETC* pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(This, pformatetcIn, ref pRemoteMedium.GetPinnableReference()); @@ -23498,7 +23498,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObjec /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, Span pformatetcIn, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(This, ref pformatetcIn.GetPinnableReference(), pRemoteMedium); @@ -23506,7 +23506,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObjec /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObject* This, Span pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(This, ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -23514,7 +23514,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, IDataObjec /// To be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, FORMATETC* pformatetcIn, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), pformatetcIn, pRemoteMedium); @@ -23522,7 +23522,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, FORMATETC* pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), pformatetcIn, ref pRemoteMedium.GetPinnableReference()); @@ -23530,7 +23530,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, Span pformatetcIn, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, Span pformatetcIn, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), pRemoteMedium); @@ -23538,7 +23538,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16022, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, Span pformatetcIn, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataStub(this Windows thisApi, Span This, Span pformatetcIn, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataStub(ref This.GetPinnableReference(), ref pformatetcIn.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -23546,7 +23546,7 @@ public static unsafe int IDataObjectGetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, FORMATETC* pformatetc, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(This, pformatetc, ref pmedium.GetPinnableReference()); @@ -23554,7 +23554,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IData /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, STGMEDIUM* pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), pmedium); @@ -23562,7 +23562,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IData /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference()); @@ -23570,7 +23570,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, IData /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, STGMEDIUM* pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, pmedium); @@ -23578,7 +23578,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference()); @@ -23586,7 +23586,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, STGMEDIUM* pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium); @@ -23594,7 +23594,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 16027, Column 41 in objidl.h")] - public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium) + public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference()); @@ -23602,7 +23602,7 @@ public static unsafe int IDataObjectGetDataHereProxy(this Windows thisApi, Span< /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, FORMATETC* pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(This, pformatetc, ref pRemoteMedium.GetPinnableReference()); @@ -23610,7 +23610,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataO /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, Span pformatetc, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(This, ref pformatetc.GetPinnableReference(), pRemoteMedium); @@ -23618,7 +23618,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataO /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, Span pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataObject* This, Span pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(This, ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -23626,7 +23626,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, IDataO /// To be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, FORMATETC* pformatetc, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), pformatetc, pRemoteMedium); @@ -23634,7 +23634,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, FORMATETC* pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), pformatetc, ref pRemoteMedium.GetPinnableReference()); @@ -23642,7 +23642,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, Span pformatetc, STGMEDIUM* pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pRemoteMedium); @@ -23650,7 +23650,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16035, Column 43 in objidl.h")] - public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, Span pformatetc, Span pRemoteMedium) + public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, Span This, Span pformatetc, Span pRemoteMedium) { // SpanOverloader return thisApi.IDataObjectGetDataHereStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pRemoteMedium.GetPinnableReference()); @@ -23658,7 +23658,7 @@ public static unsafe int IDataObjectGetDataHereStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(This, pformatetc, ref pmedium.GetPinnableReference(), fRelease); @@ -23666,7 +23666,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObje /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(This, ref pformatetc.GetPinnableReference(), pmedium, fRelease); @@ -23674,7 +23674,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObje /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); @@ -23682,7 +23682,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, IDataObje /// To be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), pformatetc, pmedium, fRelease); @@ -23690,7 +23690,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference(), fRelease); @@ -23698,7 +23698,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, Span pformatetc, TagSTGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, Span pformatetc, STGMEDIUM* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium, fRelease); @@ -23706,7 +23706,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16040, Column 41 in objidl.h")] - public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataProxy(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); @@ -23714,7 +23714,7 @@ public static unsafe int IDataObjectSetDataProxy(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(This, pformatetc, ref pmedium.GetPinnableReference(), fRelease); @@ -23722,7 +23722,7 @@ public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObjec /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(This, ref pformatetc.GetPinnableReference(), pmedium, fRelease); @@ -23730,7 +23730,7 @@ public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObjec /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObject* This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(This, ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); @@ -23738,7 +23738,7 @@ public static unsafe int IDataObjectSetDataStub(this Windows thisApi, IDataObjec /// To be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, FORMATETC* pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), pformatetc, pmedium, fRelease); @@ -23746,7 +23746,7 @@ public static unsafe int IDataObjectSetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, TagFORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, FORMATETC* pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), pformatetc, ref pmedium.GetPinnableReference(), fRelease); @@ -23754,7 +23754,7 @@ public static unsafe int IDataObjectSetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, Span pformatetc, FlagStgmedium* pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), pmedium, fRelease); @@ -23762,7 +23762,7 @@ public static unsafe int IDataObjectSetDataStub(this Windows thisApi, SpanTo be documented. [NativeName("Src", "Line 16049, Column 43 in objidl.h")] - public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) + public static unsafe int IDataObjectSetDataStub(this Windows thisApi, Span This, Span pformatetc, Span pmedium, Silk.NET.Core.Bool32 fRelease) { // SpanOverloader return thisApi.IDataObjectSetDataStub(ref This.GetPinnableReference(), ref pformatetc.GetPinnableReference(), ref pmedium.GetPinnableReference(), fRelease); diff --git a/src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt b/src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt new file mode 100644 index 0000000000..7dc5c58110 --- /dev/null +++ b/src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Shipped.txt @@ -0,0 +1 @@ +#nullable enable diff --git a/src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt b/src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt new file mode 100644 index 0000000000..7dc5c58110 --- /dev/null +++ b/src/Core/Silk.NET.SilkTouch/PublicAPI/netstandard2.1/PublicAPI.Unshipped.txt @@ -0,0 +1 @@ +#nullable enable From 1295dc2c2a9535142ede4c7911eb1b5627815ef8 Mon Sep 17 00:00:00 2001 From: Steven He Date: Sat, 23 Sep 2023 17:52:58 +0900 Subject: [PATCH 4/7] Fix WIC prefix --- build/cache/wic.json.gz | Bin 59823 -> 59823 bytes generator.json | 2 +- ...gen.cs => BitmapAlphaChannelOption.gen.cs} | 2 +- ....gen.cs => BitmapCreateCacheOption.gen.cs} | 2 +- ...en.cs => BitmapDecoderCapabilities.gen.cs} | 2 +- ...herType.gen.cs => BitmapDitherType.gen.cs} | 2 +- ...gen.cs => BitmapEncoderCacheOption.gen.cs} | 2 +- ....gen.cs => BitmapInterpolationMode.gen.cs} | 2 +- ...ockFlags.gen.cs => BitmapLockFlags.gen.cs} | 2 +- ...teType.gen.cs => BitmapPaletteType.gen.cs} | 2 +- ...s.gen.cs => BitmapTransformOptions.gen.cs} | 2 +- ...extType.gen.cs => ColorContextType.gen.cs} | 2 +- ...en.cs => ComponentEnumerateOptions.gen.cs} | 2 +- ...Signing.gen.cs => ComponentSigning.gen.cs} | 2 +- ...ponentType.gen.cs => ComponentType.gen.cs} | 2 +- ...dsAlphaMode.gen.cs => DdsAlphaMode.gen.cs} | 2 +- ...dsDimension.gen.cs => DdsDimension.gen.cs} | 2 +- ...odeOptions.gen.cs => DecodeOptions.gen.cs} | 2 +- ... GifApplicationExtensionProperties.gen.cs} | 2 +- ...s => GifCommentExtensionProperties.gen.cs} | 2 +- ...fGraphicControlExtensionProperties.gen.cs} | 2 +- ...cs => GifImageDescriptorProperties.gen.cs} | 2 +- ...fLogicalScreenDescriptorProperties.gen.cs} | 2 +- ...erties.gen.cs => HeifHdrProperties.gen.cs} | 2 +- ...roperties.gen.cs => HeifProperties.gen.cs} | 2 +- ...en.cs => JpegChrominanceProperties.gen.cs} | 2 +- ...es.gen.cs => JpegCommentProperties.gen.cs} | 2 +- ...ions.gen.cs => JpegIndexingOptions.gen.cs} | 2 +- ....gen.cs => JpegLuminanceProperties.gen.cs} | 2 +- ...pegScanType.gen.cs => JpegScanType.gen.cs} | 2 +- ...atrix.gen.cs => JpegTransferMatrix.gen.cs} | 2 +- ...n.cs => JpegYCrCbSubsamplingOption.gen.cs} | 2 +- ....gen.cs => MetadataCreationOptions.gen.cs} | 2 +- ...itePoint.gen.cs => NamedWhitePoint.gen.cs} | 2 +- ...stOptions.gen.cs => PersistOptions.gen.cs} | 2 +- ...> PixelFormatNumericRepresentation.gen.cs} | 2 +- ...narOptions.gen.cs => PlanarOptions.gen.cs} | 2 +- ...erties.gen.cs => PngBkgdProperties.gen.cs} | 2 +- ...erties.gen.cs => PngChrmProperties.gen.cs} | 2 +- ...erOption.gen.cs => PngFilterOption.gen.cs} | 2 +- ...erties.gen.cs => PngGamaProperties.gen.cs} | 2 +- ...erties.gen.cs => PngHistProperties.gen.cs} | 2 +- ...erties.gen.cs => PngIccpProperties.gen.cs} | 2 +- ...erties.gen.cs => PngItxtProperties.gen.cs} | 2 +- ...erties.gen.cs => PngSrgbProperties.gen.cs} | 2 +- ...erties.gen.cs => PngTimeProperties.gen.cs} | 2 +- ...ion.gen.cs => ProgressNotification.gen.cs} | 2 +- ...ration.gen.cs => ProgressOperation.gen.cs} | 2 +- ...bilities.gen.cs => RawCapabilities.gen.cs} | 2 +- ...meterSet.gen.cs => RawParameterSet.gen.cs} | 2 +- ...RenderMode.gen.cs => RawRenderMode.gen.cs} | 2 +- ....gen.cs => RawRotationCapabilities.gen.cs} | 2 +- ...Level.gen.cs => SectionAccessLevel.gen.cs} | 2 +- ...on.gen.cs => TiffCompressionOption.gen.cs} | 2 +- ...rties.gen.cs => WebpAnimProperties.gen.cs} | 2 +- ...rties.gen.cs => WebpAnmfProperties.gen.cs} | 2 +- ...mapPattern.gen.cs => BitmapPattern.gen.cs} | 4 +- ...CBitmapPlane.gen.cs => BitmapPlane.gen.cs} | 4 +- ...n.gen.cs => BitmapPlaneDescription.gen.cs} | 4 +- ...FormatInfo.gen.cs => DdsFormatInfo.gen.cs} | 4 +- ...Parameters.gen.cs => DdsParameters.gen.cs} | 12 +- .../WindowsCodecs/Structs/IWICBitmap.gen.cs | 54 +- .../Structs/IWICBitmapClipper.gen.cs | 54 +- .../Structs/IWICBitmapCodecInfo.gen.cs | 10 +- .../Structs/IWICBitmapDecoder.gen.cs | 10 +- .../Structs/IWICBitmapDecoderInfo.gen.cs | 50 +- .../Structs/IWICBitmapEncoder.gen.cs | 10 +- .../Structs/IWICBitmapEncoderInfo.gen.cs | 10 +- .../Structs/IWICBitmapFlipRotator.gen.cs | 40 +- .../Structs/IWICBitmapFrameDecode.gen.cs | 30 +- .../Structs/IWICBitmapFrameEncode.gen.cs | 24 +- .../Structs/IWICBitmapScaler.gen.cs | 40 +- .../Structs/IWICBitmapSource.gen.cs | 30 +- .../Structs/IWICBitmapSourceTransform.gen.cs | 68 +- .../Structs/IWICColorContext.gen.cs | 10 +- .../Structs/IWICColorTransform.gen.cs | 30 +- .../Structs/IWICComponentFactory.gen.cs | 206 +-- .../Structs/IWICComponentInfo.gen.cs | 10 +- .../Structs/IWICDdsDecoder.gen.cs | 10 +- .../Structs/IWICDdsEncoder.gen.cs | 20 +- .../Structs/IWICDdsFrameDecode.gen.cs | 40 +- .../Structs/IWICDevelopRaw.gen.cs | 102 +- .../Structs/IWICFormatConverter.gen.cs | 74 +- .../Structs/IWICFormatConverterInfo.gen.cs | 10 +- .../Structs/IWICImageEncoder.gen.cs | 144 +-- .../Structs/IWICImagingFactory.gen.cs | 206 +-- .../Structs/IWICImagingFactory2.gen.cs | 206 +-- .../Structs/IWICJpegFrameDecode.gen.cs | 24 +- .../Structs/IWICMetadataHandlerInfo.gen.cs | 10 +- .../Structs/IWICMetadataReaderInfo.gen.cs | 90 +- .../Structs/IWICMetadataWriterInfo.gen.cs | 50 +- .../WindowsCodecs/Structs/IWICPalette.gen.cs | 14 +- .../Structs/IWICPixelFormatInfo.gen.cs | 10 +- .../Structs/IWICPixelFormatInfo2.gen.cs | 20 +- .../IWICPlanarBitmapFrameEncode.gen.cs | 34 +- .../IWICPlanarBitmapSourceTransform.gen.cs | 184 +-- .../Structs/IWICPlanarFormatConverter.gen.cs | 74 +- .../Structs/IWICProgressCallback.gen.cs | 4 +- ...rameters.gen.cs => ImageParameters.gen.cs} | 4 +- ...meHeader.gen.cs => JpegFrameHeader.gen.cs} | 12 +- ...canHeader.gen.cs => JpegScanHeader.gen.cs} | 4 +- ...ataHeader.gen.cs => MetadataHeader.gen.cs} | 4 +- ...aPattern.gen.cs => MetadataPattern.gen.cs} | 4 +- .../Structs/PfnProgressNotification.gen.cs | 12 +- ...Info.gen.cs => RawCapabilitiesInfo.gen.cs} | 60 +- ...awToneCurve.gen.cs => RawToneCurve.gen.cs} | 12 +- ...ePoint.gen.cs => RawToneCurvePoint.gen.cs} | 4 +- .../Structs/{WICRect.gen.cs => Rect.gen.cs} | 4 +- .../WICBitmapClipperVtblExtensions.gen.cs | 68 +- .../WICBitmapCodecInfoVtblExtensions.gen.cs | 12 +- .../WICBitmapDecoderInfoVtblExtensions.gen.cs | 66 +- .../WICBitmapDecoderVtblExtensions.gen.cs | 12 +- .../WICBitmapEncoderInfoVtblExtensions.gen.cs | 12 +- .../WICBitmapEncoderVtblExtensions.gen.cs | 12 +- .../WICBitmapFlipRotatorVtblExtensions.gen.cs | 50 +- .../WICBitmapFrameDecodeVtblExtensions.gen.cs | 38 +- .../WICBitmapFrameEncodeVtblExtensions.gen.cs | 30 +- .../WICBitmapScalerVtblExtensions.gen.cs | 50 +- ...BitmapSourceTransformVtblExtensions.gen.cs | 90 +- .../WICBitmapSourceVtblExtensions.gen.cs | 38 +- .../Structs/WICBitmapVtblExtensions.gen.cs | 66 +- .../WICColorContextVtblExtensions.gen.cs | 12 +- .../WICColorTransformVtblExtensions.gen.cs | 38 +- .../WICComponentFactoryVtblExtensions.gen.cs | 258 ++-- .../WICComponentInfoVtblExtensions.gen.cs | 12 +- .../WICDdsDecoderVtblExtensions.gen.cs | 12 +- .../WICDdsEncoderVtblExtensions.gen.cs | 24 +- .../WICDdsFrameDecodeVtblExtensions.gen.cs | 50 +- .../WICDevelopRawVtblExtensions.gen.cs | 124 +- ...ICFormatConverterInfoVtblExtensions.gen.cs | 12 +- .../WICFormatConverterVtblExtensions.gen.cs | 96 +- .../WICImageEncoderVtblExtensions.gen.cs | 186 +-- .../WICImagingFactory2VtblExtensions.gen.cs | 258 ++-- .../WICImagingFactoryVtblExtensions.gen.cs | 258 ++-- .../WICJpegFrameDecodeVtblExtensions.gen.cs | 28 +- ...ICMetadataHandlerInfoVtblExtensions.gen.cs | 12 +- ...WICMetadataReaderInfoVtblExtensions.gen.cs | 122 +- ...WICMetadataWriterInfoVtblExtensions.gen.cs | 66 +- .../Structs/WICPaletteVtblExtensions.gen.cs | 16 +- .../WICPixelFormatInfo2VtblExtensions.gen.cs | 24 +- .../WICPixelFormatInfoVtblExtensions.gen.cs | 12 +- ...anarBitmapFrameEncodeVtblExtensions.gen.cs | 40 +- ...BitmapSourceTransformVtblExtensions.gen.cs | 252 ++-- ...PlanarFormatConverterVtblExtensions.gen.cs | 94 +- .../WICProgressCallbackVtblExtensions.gen.cs | 4 +- .../WindowsCodecs/WindowsCodecs.gen.cs | 1128 ++++++++--------- .../WindowsCodecsOverloads.gen.cs | 756 +++++------ 147 files changed, 3354 insertions(+), 3354 deletions(-) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapAlphaChannelOption.gen.cs => BitmapAlphaChannelOption.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapCreateCacheOption.gen.cs => BitmapCreateCacheOption.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapDecoderCapabilities.gen.cs => BitmapDecoderCapabilities.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapDitherType.gen.cs => BitmapDitherType.gen.cs} (97%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapEncoderCacheOption.gen.cs => BitmapEncoderCacheOption.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapInterpolationMode.gen.cs => BitmapInterpolationMode.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapLockFlags.gen.cs => BitmapLockFlags.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapPaletteType.gen.cs => BitmapPaletteType.gen.cs} (97%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICBitmapTransformOptions.gen.cs => BitmapTransformOptions.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICColorContextType.gen.cs => ColorContextType.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICComponentEnumerateOptions.gen.cs => ComponentEnumerateOptions.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICComponentSigning.gen.cs => ComponentSigning.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICComponentType.gen.cs => ComponentType.gen.cs} (96%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICDdsAlphaMode.gen.cs => DdsAlphaMode.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICDdsDimension.gen.cs => DdsDimension.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICDecodeOptions.gen.cs => DecodeOptions.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICGifApplicationExtensionProperties.gen.cs => GifApplicationExtensionProperties.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICGifCommentExtensionProperties.gen.cs => GifCommentExtensionProperties.gen.cs} (90%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICGifGraphicControlExtensionProperties.gen.cs => GifGraphicControlExtensionProperties.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICGifImageDescriptorProperties.gen.cs => GifImageDescriptorProperties.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICGifLogicalScreenDescriptorProperties.gen.cs => GifLogicalScreenDescriptorProperties.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICHeifHdrProperties.gen.cs => HeifHdrProperties.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICHeifProperties.gen.cs => HeifProperties.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegChrominanceProperties.gen.cs => JpegChrominanceProperties.gen.cs} (90%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegCommentProperties.gen.cs => JpegCommentProperties.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegIndexingOptions.gen.cs => JpegIndexingOptions.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegLuminanceProperties.gen.cs => JpegLuminanceProperties.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegScanType.gen.cs => JpegScanType.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegTransferMatrix.gen.cs => JpegTransferMatrix.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICJpegYCrCbSubsamplingOption.gen.cs => JpegYCrCbSubsamplingOption.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICMetadataCreationOptions.gen.cs => MetadataCreationOptions.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICNamedWhitePoint.gen.cs => NamedWhitePoint.gen.cs} (97%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPersistOptions.gen.cs => PersistOptions.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPixelFormatNumericRepresentation.gen.cs => PixelFormatNumericRepresentation.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPlanarOptions.gen.cs => PlanarOptions.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngBkgdProperties.gen.cs => PngBkgdProperties.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngChrmProperties.gen.cs => PngChrmProperties.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngFilterOption.gen.cs => PngFilterOption.gen.cs} (96%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngGamaProperties.gen.cs => PngGamaProperties.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngHistProperties.gen.cs => PngHistProperties.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngIccpProperties.gen.cs => PngIccpProperties.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngItxtProperties.gen.cs => PngItxtProperties.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngSrgbProperties.gen.cs => PngSrgbProperties.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICPngTimeProperties.gen.cs => PngTimeProperties.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICProgressNotification.gen.cs => ProgressNotification.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICProgressOperation.gen.cs => ProgressOperation.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICRawCapabilities.gen.cs => RawCapabilities.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICRawParameterSet.gen.cs => RawParameterSet.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICRawRenderMode.gen.cs => RawRenderMode.gen.cs} (94%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICRawRotationCapabilities.gen.cs => RawRotationCapabilities.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICSectionAccessLevel.gen.cs => SectionAccessLevel.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICTiffCompressionOption.gen.cs => TiffCompressionOption.gen.cs} (96%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICWebpAnimProperties.gen.cs => WebpAnimProperties.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{WICWebpAnmfProperties.gen.cs => WebpAnmfProperties.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICBitmapPattern.gen.cs => BitmapPattern.gen.cs} (96%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICBitmapPlane.gen.cs => BitmapPlane.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICBitmapPlaneDescription.gen.cs => BitmapPlaneDescription.gen.cs} (93%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICDdsFormatInfo.gen.cs => DdsFormatInfo.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICDdsParameters.gen.cs => DdsParameters.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICImageParameters.gen.cs => ImageParameters.gen.cs} (96%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICJpegFrameHeader.gen.cs => JpegFrameHeader.gen.cs} (91%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICJpegScanHeader.gen.cs => JpegScanHeader.gen.cs} (97%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICMetadataHeader.gen.cs => MetadataHeader.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICMetadataPattern.gen.cs => MetadataPattern.gen.cs} (95%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICRawCapabilitiesInfo.gen.cs => RawCapabilitiesInfo.gen.cs} (78%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICRawToneCurve.gen.cs => RawToneCurve.gen.cs} (83%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICRawToneCurvePoint.gen.cs => RawToneCurvePoint.gen.cs} (92%) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/{WICRect.gen.cs => Rect.gen.cs} (96%) diff --git a/build/cache/wic.json.gz b/build/cache/wic.json.gz index 073473dbfc751e5b00a1fc3bc936c0d952782e6a..fa5988956f320fdd00bd83b81a9f840d9e534b70 100644 GIT binary patch delta 56309 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 delta 56396 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

@&W=l07uy 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 SYwbGqkaH%x)~rqS(EL9j&wnQX diff --git a/generator.json b/generator.json index db3a345ac6..f90247a0ef 100644 --- a/generator.json +++ b/generator.json @@ -1599,7 +1599,7 @@ "no-extra-dir" ], "converter": {}, - "prefix": "WIC_", + "prefix": "WIC", "clang": { "args": [ "--language=c++", diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapAlphaChannelOption.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapAlphaChannelOption.gen.cs index dba8ced1b3..954080bd81 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapAlphaChannelOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapAlphaChannelOption.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapAlphaChannelOption")] - public enum WICBitmapAlphaChannelOption : int + public enum BitmapAlphaChannelOption : int { [NativeName("Name", "WICBitmapUseAlpha")] BitmapUseAlpha = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapCreateCacheOption.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapCreateCacheOption.gen.cs index 7f3d1df914..6c33457417 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapCreateCacheOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapCreateCacheOption.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapCreateCacheOption")] - public enum WICBitmapCreateCacheOption : int + public enum BitmapCreateCacheOption : int { [NativeName("Name", "WICBitmapNoCache")] BitmapNoCache = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapDecoderCapabilities.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapDecoderCapabilities.gen.cs index b21c220065..307e9670dc 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDecoderCapabilities.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapDecoderCapabilities.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICBitmapDecoderCapabilities")] - public enum WICBitmapDecoderCapabilities : int + public enum BitmapDecoderCapabilities : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapDitherType.gen.cs similarity index 97% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapDitherType.gen.cs index 588010c44c..5e2b19310b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapDitherType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapDitherType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapDitherType")] - public enum WICBitmapDitherType : int + public enum BitmapDitherType : int { [NativeName("Name", "WICBitmapDitherTypeNone")] BitmapDitherTypeNone = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapEncoderCacheOption.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapEncoderCacheOption.gen.cs index a62303e690..6adcb8f553 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapEncoderCacheOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapEncoderCacheOption.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapEncoderCacheOption")] - public enum WICBitmapEncoderCacheOption : int + public enum BitmapEncoderCacheOption : int { [NativeName("Name", "WICBitmapEncoderCacheInMemory")] BitmapEncoderCacheInMemory = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapInterpolationMode.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapInterpolationMode.gen.cs index 762723fab1..5cb9e59372 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapInterpolationMode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapInterpolationMode.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapInterpolationMode")] - public enum WICBitmapInterpolationMode : int + public enum BitmapInterpolationMode : int { [NativeName("Name", "WICBitmapInterpolationModeNearestNeighbor")] BitmapInterpolationModeNearestNeighbor = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapLockFlags.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapLockFlags.gen.cs index 131f070a2c..e22aea5b31 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapLockFlags.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapLockFlags.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapLockFlags")] - public enum WICBitmapLockFlags : int + public enum BitmapLockFlags : int { [NativeName("Name", "WICBitmapLockRead")] BitmapLockRead = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapPaletteType.gen.cs similarity index 97% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapPaletteType.gen.cs index 8bac80e60d..aaf967c597 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapPaletteType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapPaletteType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapPaletteType")] - public enum WICBitmapPaletteType : int + public enum BitmapPaletteType : int { [NativeName("Name", "WICBitmapPaletteTypeCustom")] BitmapPaletteTypeCustom = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapTransformOptions.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapTransformOptions.gen.cs index c8e20fe461..8b69fc44e9 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICBitmapTransformOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/BitmapTransformOptions.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICBitmapTransformOptions")] - public enum WICBitmapTransformOptions : int + public enum BitmapTransformOptions : int { [NativeName("Name", "WICBitmapTransformRotate0")] BitmapTransformRotate0 = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ColorContextType.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ColorContextType.gen.cs index 8c828149ea..cbcbc5a9bd 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICColorContextType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ColorContextType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICColorContextType")] - public enum WICColorContextType : int + public enum ColorContextType : int { [NativeName("Name", "WICColorContextUninitialized")] Uninitialized = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentEnumerateOptions.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentEnumerateOptions.gen.cs index 994633d54a..bbf1efa93e 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentEnumerateOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentEnumerateOptions.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICComponentEnumerateOptions")] - public enum WICComponentEnumerateOptions : int + public enum ComponentEnumerateOptions : int { [NativeName("Name", "WICComponentEnumerateDefault")] ComponentEnumerateDefault = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentSigning.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentSigning.gen.cs index 255b7dfcee..25c58d8701 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentSigning.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentSigning.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICComponentSigning")] - public enum WICComponentSigning : int + public enum ComponentSigning : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentType.gen.cs similarity index 96% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentType.gen.cs index 09b2fa0cde..889f36108a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICComponentType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ComponentType.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICComponentType")] - public enum WICComponentType : int + public enum ComponentType : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DdsAlphaMode.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DdsAlphaMode.gen.cs index a18ca88dff..cfe1b93ac0 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsAlphaMode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DdsAlphaMode.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICDdsAlphaMode")] - public enum WICDdsAlphaMode : int + public enum DdsAlphaMode : int { [NativeName("Name", "WICDdsAlphaModeUnknown")] DdsAlphaModeUnknown = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DdsDimension.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DdsDimension.gen.cs index b43020c592..1f8f33cc01 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDdsDimension.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DdsDimension.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICDdsDimension")] - public enum WICDdsDimension : int + public enum DdsDimension : int { [NativeName("Name", "WICDdsTexture1D")] DdsTexture1D = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DecodeOptions.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DecodeOptions.gen.cs index ada1b50742..764b98c6b9 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICDecodeOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/DecodeOptions.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICDecodeOptions")] - public enum WICDecodeOptions : int + public enum DecodeOptions : int { [NativeName("Name", "WICDecodeMetadataCacheOnDemand")] DecodeMetadataCacheOnDemand = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifApplicationExtensionProperties.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifApplicationExtensionProperties.gen.cs index f2c40d3fa7..cc2998623a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifApplicationExtensionProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifApplicationExtensionProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICGifApplicationExtensionProperties")] - public enum WICGifApplicationExtensionProperties : int + public enum GifApplicationExtensionProperties : int { [NativeName("Name", "WICGifApplicationExtensionApplication")] Application = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifCommentExtensionProperties.gen.cs similarity index 90% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifCommentExtensionProperties.gen.cs index 7afbf8ac63..2871243564 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifCommentExtensionProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifCommentExtensionProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICGifCommentExtensionProperties")] - public enum WICGifCommentExtensionProperties : int + public enum GifCommentExtensionProperties : int { [NativeName("Name", "WICGifCommentExtensionText")] Text = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifGraphicControlExtensionProperties.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifGraphicControlExtensionProperties.gen.cs index 1b5c4cbb0c..5760e0b3d8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifGraphicControlExtensionProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifGraphicControlExtensionProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICGifGraphicControlExtensionProperties")] - public enum WICGifGraphicControlExtensionProperties : int + public enum GifGraphicControlExtensionProperties : int { [NativeName("Name", "WICGifGraphicControlExtensionDisposal")] Disposal = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifImageDescriptorProperties.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifImageDescriptorProperties.gen.cs index 92b12f3123..67acf54b9d 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifImageDescriptorProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifImageDescriptorProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICGifImageDescriptorProperties")] - public enum WICGifImageDescriptorProperties : int + public enum GifImageDescriptorProperties : int { [NativeName("Name", "WICGifImageDescriptorLeft")] Left = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifLogicalScreenDescriptorProperties.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifLogicalScreenDescriptorProperties.gen.cs index 6648796638..cee6d063f1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICGifLogicalScreenDescriptorProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/GifLogicalScreenDescriptorProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICGifLogicalScreenDescriptorProperties")] - public enum WICGifLogicalScreenDescriptorProperties : int + public enum GifLogicalScreenDescriptorProperties : int { [NativeName("Name", "WICGifLogicalScreenSignature")] Signature = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/HeifHdrProperties.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/HeifHdrProperties.gen.cs index 35fe37e0eb..0f589a0aea 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifHdrProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/HeifHdrProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICHeifHdrProperties")] - public enum WICHeifHdrProperties : int + public enum HeifHdrProperties : int { [NativeName("Name", "WICHeifHdrMaximumLuminanceLevel")] MaximumLuminanceLevel = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/HeifProperties.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/HeifProperties.gen.cs index 1925b982e7..b984ed548a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICHeifProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/HeifProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICHeifProperties")] - public enum WICHeifProperties : int + public enum HeifProperties : int { [NativeName("Name", "WICHeifOrientation")] Orientation = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegChrominanceProperties.gen.cs similarity index 90% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegChrominanceProperties.gen.cs index ae39087034..242a05277a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegChrominanceProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegChrominanceProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegChrominanceProperties")] - public enum WICJpegChrominanceProperties : int + public enum JpegChrominanceProperties : int { [NativeName("Name", "WICJpegChrominanceTable")] Table = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegCommentProperties.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegCommentProperties.gen.cs index e481f53547..b88779e276 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegCommentProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegCommentProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegCommentProperties")] - public enum WICJpegCommentProperties : int + public enum JpegCommentProperties : int { [NativeName("Name", "WICJpegCommentText")] Text = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegIndexingOptions.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegIndexingOptions.gen.cs index fe66fd0fc9..cf177ef773 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegIndexingOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegIndexingOptions.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegIndexingOptions")] - public enum WICJpegIndexingOptions : int + public enum JpegIndexingOptions : int { [NativeName("Name", "WICJpegIndexingOptionsGenerateOnDemand")] GenerateOnDemand = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegLuminanceProperties.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegLuminanceProperties.gen.cs index a4105331cf..c2387541c4 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegLuminanceProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegLuminanceProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegLuminanceProperties")] - public enum WICJpegLuminanceProperties : int + public enum JpegLuminanceProperties : int { [NativeName("Name", "WICJpegLuminanceTable")] Table = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegScanType.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegScanType.gen.cs index e1ce5b539e..bdbca60dde 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegScanType.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegScanType.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegScanType")] - public enum WICJpegScanType : int + public enum JpegScanType : int { [NativeName("Name", "WICJpegScanTypeInterleaved")] Interleaved = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegTransferMatrix.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegTransferMatrix.gen.cs index 45dc3837b1..d260f00b30 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegTransferMatrix.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegTransferMatrix.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegTransferMatrix")] - public enum WICJpegTransferMatrix : int + public enum JpegTransferMatrix : int { [NativeName("Name", "WICJpegTransferMatrixIdentity")] Identity = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegYCrCbSubsamplingOption.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegYCrCbSubsamplingOption.gen.cs index b8ecc553da..c6fe6fd5f6 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICJpegYCrCbSubsamplingOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/JpegYCrCbSubsamplingOption.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegYCrCbSubsamplingOption")] - public enum WICJpegYCrCbSubsamplingOption : int + public enum JpegYCrCbSubsamplingOption : int { [NativeName("Name", "WICJpegYCrCbSubsamplingDefault")] JpegYCrCbSubsamplingDefault = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/MetadataCreationOptions.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/MetadataCreationOptions.gen.cs index 200eb8e5a0..0a3e256ea1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICMetadataCreationOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/MetadataCreationOptions.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICMetadataCreationOptions")] - public enum WICMetadataCreationOptions : int + public enum MetadataCreationOptions : int { [NativeName("Name", "WICMetadataCreationDefault")] Default = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/NamedWhitePoint.gen.cs similarity index 97% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/NamedWhitePoint.gen.cs index eb19f5a2ae..31f9ffc70c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICNamedWhitePoint.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/NamedWhitePoint.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICNamedWhitePoint")] - public enum WICNamedWhitePoint : int + public enum NamedWhitePoint : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PersistOptions.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PersistOptions.gen.cs index 88228f9354..96b5ec8aa2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPersistOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PersistOptions.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICPersistOptions")] - public enum WICPersistOptions : int + public enum PersistOptions : int { [NativeName("Name", "WICPersistOptionDefault")] Default = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PixelFormatNumericRepresentation.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PixelFormatNumericRepresentation.gen.cs index 893886f0e7..793f3844d5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPixelFormatNumericRepresentation.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PixelFormatNumericRepresentation.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPixelFormatNumericRepresentation")] - public enum WICPixelFormatNumericRepresentation : int + public enum PixelFormatNumericRepresentation : int { [NativeName("Name", "WICPixelFormatNumericRepresentationUnspecified")] Unspecified = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PlanarOptions.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PlanarOptions.gen.cs index 6f6ce7a849..abaffed86b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPlanarOptions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PlanarOptions.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPlanarOptions")] - public enum WICPlanarOptions : int + public enum PlanarOptions : int { [NativeName("Name", "WICPlanarOptionsDefault")] PlanarOptionsDefault = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngBkgdProperties.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngBkgdProperties.gen.cs index edb2a1a1b8..d71fa22d7b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngBkgdProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngBkgdProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngBkgdProperties")] - public enum WICPngBkgdProperties : int + public enum PngBkgdProperties : int { [NativeName("Name", "WICPngBkgdBackgroundColor")] BackgroundColor = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngChrmProperties.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngChrmProperties.gen.cs index 33f9429bb7..3c71abdb75 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngChrmProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngChrmProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngChrmProperties")] - public enum WICPngChrmProperties : int + public enum PngChrmProperties : int { [NativeName("Name", "WICPngChrmWhitePointX")] WhitePointX = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngFilterOption.gen.cs similarity index 96% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngFilterOption.gen.cs index 99bb605ca2..f5c9ec7046 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngFilterOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngFilterOption.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngFilterOption")] - public enum WICPngFilterOption : int + public enum PngFilterOption : int { [NativeName("Name", "WICPngFilterUnspecified")] PngFilterUnspecified = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngGamaProperties.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngGamaProperties.gen.cs index 1488b854c9..7dea55c2d7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngGamaProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngGamaProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngGamaProperties")] - public enum WICPngGamaProperties : int + public enum PngGamaProperties : int { [NativeName("Name", "WICPngGamaGamma")] Gamma = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngHistProperties.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngHistProperties.gen.cs index 1122c57fc8..ca43a9ab85 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngHistProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngHistProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngHistProperties")] - public enum WICPngHistProperties : int + public enum PngHistProperties : int { [NativeName("Name", "WICPngHistFrequencies")] Frequencies = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngIccpProperties.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngIccpProperties.gen.cs index dfecc0b8dc..94e556f812 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngIccpProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngIccpProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngIccpProperties")] - public enum WICPngIccpProperties : int + public enum PngIccpProperties : int { [NativeName("Name", "WICPngIccpProfileName")] ProfileName = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngItxtProperties.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngItxtProperties.gen.cs index 4948dea424..a97a9d642d 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngItxtProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngItxtProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngItxtProperties")] - public enum WICPngItxtProperties : int + public enum PngItxtProperties : int { [NativeName("Name", "WICPngItxtKeyword")] Keyword = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngSrgbProperties.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngSrgbProperties.gen.cs index c252cd33b5..4ea228511b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngSrgbProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngSrgbProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngSrgbProperties")] - public enum WICPngSrgbProperties : int + public enum PngSrgbProperties : int { [NativeName("Name", "WICPngSrgbRenderingIntent")] RenderingIntent = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngTimeProperties.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngTimeProperties.gen.cs index 88177c8d26..1a9a289962 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICPngTimeProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/PngTimeProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICPngTimeProperties")] - public enum WICPngTimeProperties : int + public enum PngTimeProperties : int { [NativeName("Name", "WICPngTimeYear")] Year = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotification.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotification.gen.cs index 063ce4cf0c..1e097b9326 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressNotification.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotification.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICProgressNotification")] - public enum WICProgressNotification : int + public enum ProgressNotification : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressOperation.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressOperation.gen.cs index 23e8a63f13..068dc6ea8b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICProgressOperation.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressOperation.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICProgressOperation")] - public enum WICProgressOperation : int + public enum ProgressOperation : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawCapabilities.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawCapabilities.gen.cs index fe646ae075..a74a6bad71 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawCapabilities.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawCapabilities.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawCapabilities")] - public enum WICRawCapabilities : int + public enum RawCapabilities : int { [NativeName("Name", "WICRawCapabilityNotSupported")] RawCapabilityNotSupported = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawParameterSet.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawParameterSet.gen.cs index e40415c6da..478061ecab 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawParameterSet.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawParameterSet.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawParameterSet")] - public enum WICRawParameterSet : int + public enum RawParameterSet : int { [NativeName("Name", "WICAsShotParameterSet")] AsShotParameterSet = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawRenderMode.gen.cs similarity index 94% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawRenderMode.gen.cs index 80f5e1d143..d869954227 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRenderMode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawRenderMode.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawRenderMode")] - public enum WICRawRenderMode : int + public enum RawRenderMode : int { [NativeName("Name", "WICRawRenderModeDraft")] RawRenderModeDraft = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawRotationCapabilities.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawRotationCapabilities.gen.cs index 3646178df4..caf518bc18 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICRawRotationCapabilities.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/RawRotationCapabilities.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawRotationCapabilities")] - public enum WICRawRotationCapabilities : int + public enum RawRotationCapabilities : int { [NativeName("Name", "WICRawRotationCapabilityNotSupported")] RawRotationCapabilityNotSupported = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/SectionAccessLevel.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/SectionAccessLevel.gen.cs index cc47553ea8..c4db52f6ea 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICSectionAccessLevel.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/SectionAccessLevel.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICSectionAccessLevel")] - public enum WICSectionAccessLevel : int + public enum SectionAccessLevel : int { [NativeName("Name", "")] None = 0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/TiffCompressionOption.gen.cs similarity index 96% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/TiffCompressionOption.gen.cs index 4af0387b34..fc112b90f7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICTiffCompressionOption.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/TiffCompressionOption.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICTiffCompressionOption")] - public enum WICTiffCompressionOption : int + public enum TiffCompressionOption : int { [NativeName("Name", "WICTiffCompressionDontCare")] TiffCompressionDontCare = 0x0, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WebpAnimProperties.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WebpAnimProperties.gen.cs index f0ee2650e6..1b616cbd24 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnimProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WebpAnimProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICWebpAnimProperties")] - public enum WICWebpAnimProperties : int + public enum WebpAnimProperties : int { [NativeName("Name", "WICWebpAnimLoopCount")] LoopCount = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WebpAnmfProperties.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WebpAnmfProperties.gen.cs index 449ba4ee22..02e0248046 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WICWebpAnmfProperties.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/WebpAnmfProperties.gen.cs @@ -10,7 +10,7 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICWebpAnmfProperties")] - public enum WICWebpAnmfProperties : int + public enum WebpAnmfProperties : int { [NativeName("Name", "WICWebpAnmfFrameDuration")] FrameDuration = 0x1, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPattern.gen.cs similarity index 96% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPattern.gen.cs index 3b37a66309..89abd1c2a6 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPattern.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPattern.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapPattern")] - public unsafe partial struct WICBitmapPattern + public unsafe partial struct BitmapPattern { - public WICBitmapPattern + public BitmapPattern ( ulong? position = null, uint? length = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPlane.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPlane.gen.cs index e7f420440c..83dc28f3a5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlane.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPlane.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapPlane")] - public unsafe partial struct WICBitmapPlane + public unsafe partial struct BitmapPlane { - public WICBitmapPlane + public BitmapPlane ( Guid? format = null, byte* pbBuffer = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPlaneDescription.gen.cs similarity index 93% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPlaneDescription.gen.cs index 9c3e5ce433..f83e7e1a9b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapPlaneDescription.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/BitmapPlaneDescription.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICBitmapPlaneDescription")] - public unsafe partial struct WICBitmapPlaneDescription + public unsafe partial struct BitmapPlaneDescription { - public WICBitmapPlaneDescription + public BitmapPlaneDescription ( Guid? format = null, uint? width = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/DdsFormatInfo.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/DdsFormatInfo.gen.cs index f3364e1a87..8ea1b24e5a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFormatInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/DdsFormatInfo.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICDdsFormatInfo")] - public unsafe partial struct WICDdsFormatInfo + public unsafe partial struct DdsFormatInfo { - public WICDdsFormatInfo + public DdsFormatInfo ( Silk.NET.DXGI.Format? dxgiFormat = null, uint? bytesPerBlock = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/DdsParameters.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/DdsParameters.gen.cs index 3536a61d40..9c6c1cdecd 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsParameters.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/DdsParameters.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICDdsParameters")] - public unsafe partial struct WICDdsParameters + public unsafe partial struct DdsParameters { - public WICDdsParameters + public DdsParameters ( uint? width = null, uint? height = null, @@ -27,8 +27,8 @@ public WICDdsParameters uint? mipLevels = null, uint? arraySize = null, Silk.NET.DXGI.Format? dxgiFormat = null, - WICDdsDimension? dimension = null, - WICDdsAlphaMode? alphaMode = null + DdsDimension? dimension = null, + DdsAlphaMode? alphaMode = null ) : this() { if (width is not null) @@ -106,11 +106,11 @@ public WICDdsParameters [NativeName("Type", "WICDdsDimension")] [NativeName("Type.Name", "WICDdsDimension")] [NativeName("Name", "Dimension")] - public WICDdsDimension Dimension; + public DdsDimension Dimension; [NativeName("Type", "WICDdsAlphaMode")] [NativeName("Type.Name", "WICDdsAlphaMode")] [NativeName("Name", "AlphaMode")] - public WICDdsAlphaMode AlphaMode; + public DdsAlphaMode AlphaMode; } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs index 1584802c36..e9897a8215 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs @@ -252,121 +252,121 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } ///

To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, IWICBitmapLock** ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref IWICBitmapLock* ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); } return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, IWICBitmapLock** ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcLockPtr = &prcLock) + fixed (Rect* prcLockPtr = &prcLock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); } return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref IWICBitmapLock* ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcLockPtr = &prcLock) + fixed (Rect* prcLockPtr = &prcLock) { fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); } } return ret; @@ -420,7 +420,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -428,7 +428,7 @@ public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In } /// To be documented. - public readonly int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs index a57df38dc5..0f587363d8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs @@ -252,121 +252,121 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); } return ret; } /// To be documented. - public readonly int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + public readonly int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); } } return ret; @@ -390,7 +390,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -398,7 +398,7 @@ public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET. } /// To be documented. - public readonly int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs index 9a668d336a..886ff662d2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapCodecInfo.gen.cs @@ -114,22 +114,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICBitmapCodecInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs index 38af3f4835..9a1c3afbcc 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoder.gen.cs @@ -159,22 +159,22 @@ public readonly int QueryCapability(ref Silk.NET.Core.Win32Extras.IStream pIStre } /// To be documented. - public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IStream* pIStream, WICDecodeOptions cacheOptions) + public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IStream* pIStream, DecodeOptions cacheOptions) { var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, cacheOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, cacheOptions); return ret; } /// To be documented. - public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IStream pIStream, WICDecodeOptions cacheOptions) + public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IStream pIStream, DecodeOptions cacheOptions) { var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, cacheOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, cacheOptions); } return ret; } @@ -421,7 +421,7 @@ public readonly int QueryCapability(ComPtr pIStream, ref uint pdwCapab } /// To be documented. - public readonly int Initialize(ComPtr pIStream, WICDecodeOptions cacheOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pIStream, DecodeOptions cacheOptions) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs index 5cd71aae3b..073761b449 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapDecoderInfo.gen.cs @@ -117,22 +117,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -1084,40 +1084,40 @@ public readonly int MatchesMimeType([Flow(Silk.NET.Core.Native.FlowDirection.In) } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); return ret; } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActualPtr); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pcPatternsPtr = &pcPatterns) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActual); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1125,66 +1125,66 @@ public readonly unsafe int GetPatterns(uint cbSizePatterns, WICBitmapPattern* pP { fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActual); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + public readonly unsafe int GetPatterns(uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { fixed (uint* pcPatternsPtr = &pcPatterns) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActual); } } return ret; } /// To be documented. - public readonly int GetPatterns(uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + public readonly int GetPatterns(uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) { var @this = (IWICBitmapDecoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { fixed (uint* pcPatternsPtr = &pcPatterns) { fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActualPtr); } } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs index dedac5b76a..d27d6f85d6 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoder.gen.cs @@ -111,22 +111,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IStream* pIStream, WICBitmapEncoderCacheOption cacheOption) + public readonly unsafe int Initialize(Silk.NET.Core.Win32Extras.IStream* pIStream, BitmapEncoderCacheOption cacheOption) { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, cacheOption); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, cacheOption); return ret; } /// To be documented. - public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IStream pIStream, WICBitmapEncoderCacheOption cacheOption) + public readonly int Initialize(ref Silk.NET.Core.Win32Extras.IStream pIStream, BitmapEncoderCacheOption cacheOption) { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, cacheOption); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, cacheOption); } return ret; } @@ -345,7 +345,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly int Initialize(ComPtr pIStream, WICBitmapEncoderCacheOption cacheOption) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pIStream, BitmapEncoderCacheOption cacheOption) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs index b579b93179..cedd24c181 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapEncoderInfo.gen.cs @@ -117,22 +117,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICBitmapEncoderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs index 4bfecf876a..09f0f75df4 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs @@ -252,95 +252,95 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, WICBitmapTransformOptions options) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, BitmapTransformOptions options) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, options); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, options); return ret; } /// To be documented. - public readonly int Initialize(ref IWICBitmapSource pISource, WICBitmapTransformOptions options) + public readonly int Initialize(ref IWICBitmapSource pISource, BitmapTransformOptions options) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, options); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, options); } return ret; } @@ -363,7 +363,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly int Initialize(ComPtr pISource, WICBitmapTransformOptions options) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pISource, BitmapTransformOptions options) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs index 431c21d99d..49f04b5ae1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs index 6f0d3c956e..d360483453 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs @@ -266,48 +266,48 @@ public readonly int WritePixels(uint lineCount, uint cbStride, uint cbBufferSize } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, WICRect* prc) + public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, Rect* prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); return ret; } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, ref WICRect prc) + public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, ref Rect prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(ref IWICBitmapSource pIBitmapSource, WICRect* prc) + public readonly unsafe int WriteSource(ref IWICBitmapSource pIBitmapSource, Rect* prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); } return ret; } /// To be documented. - public readonly int WriteSource(ref IWICBitmapSource pIBitmapSource, ref WICRect prc) + public readonly int WriteSource(ref IWICBitmapSource pIBitmapSource, ref Rect prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); } } return ret; @@ -385,7 +385,7 @@ public readonly int SetThumbnail(ComPtr pIThumbnail) where TI0 : unman } /// To be documented. - public readonly unsafe int WriteSource(ComPtr pIBitmapSource, WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteSource(ComPtr pIBitmapSource, Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -393,7 +393,7 @@ public readonly unsafe int WriteSource(ComPtr pIBitmapSource, WICRect* } /// To be documented. - public readonly int WriteSource(ComPtr pIBitmapSource, ref WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteSource(ComPtr pIBitmapSource, ref Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs index 1397704f3f..ba0156ceb1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs @@ -252,95 +252,95 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, uiWidth, uiHeight, mode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, uiWidth, uiHeight, mode); return ret; } /// To be documented. - public readonly int Initialize(ref IWICBitmapSource pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + public readonly int Initialize(ref IWICBitmapSource pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, uiWidth, uiHeight, mode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, uiWidth, uiHeight, mode); } return ret; } @@ -363,7 +363,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly int Initialize(ComPtr pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs index f95e66ebcb..8aa7504d3c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs @@ -249,73 +249,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs index a0f39ab9ce..b1a637d2a7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs @@ -111,51 +111,51 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -163,94 +163,94 @@ public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.I { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } } @@ -258,16 +258,16 @@ public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } } @@ -344,22 +344,22 @@ public readonly int GetClosestPixelFormat(ref Guid pguidDstFormat) } /// To be documented. - public readonly unsafe int DoesSupportTransform(WICBitmapTransformOptions dstTransform, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(BitmapTransformOptions dstTransform, int* pfIsSupported) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupported); return ret; } /// To be documented. - public readonly int DoesSupportTransform(WICBitmapTransformOptions dstTransform, ref int pfIsSupported) + public readonly int DoesSupportTransform(BitmapTransformOptions dstTransform, ref int pfIsSupported) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupportedPtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs index c020d09127..7268ad9336 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorContext.gen.cs @@ -184,22 +184,22 @@ public readonly int InitializeFromExifColorSpace(uint value) } /// To be documented. - public readonly unsafe int GetType(WICColorContextType* pType) + public readonly unsafe int GetType(ColorContextType* pType) { var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pType); return ret; } /// To be documented. - public readonly int GetType(ref WICColorContextType pType) + public readonly int GetType(ref ColorContextType pType) { var @this = (IWICColorContext*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICColorContextType* pTypePtr = &pType) + fixed (ColorContextType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs index 5b976cc888..739c8919c5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs index 3dddac412b..e926c0a05d 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentFactory.gen.cs @@ -114,40 +114,40 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -155,26 +155,26 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzFilenamePtr = &wzFilename) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -182,14 +182,14 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -197,14 +197,14 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -214,7 +214,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } } @@ -222,46 +222,46 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -270,7 +270,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } SilkMarshal.Free((nint)wzFilenamePtr); @@ -278,40 +278,40 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -319,26 +319,26 @@ public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.ISt { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -346,14 +346,14 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -361,14 +361,14 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -378,7 +378,7 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } } @@ -386,40 +386,40 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -427,7 +427,7 @@ public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.N { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; @@ -866,40 +866,40 @@ public readonly unsafe int CreateColorTransformer(ref IWICColorTransform* ppIWIC } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pixelFormatPtr = &pixelFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -907,47 +907,47 @@ public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pi { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -955,7 +955,7 @@ public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapS { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); } } return ret; @@ -1174,40 +1174,40 @@ public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, r } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1215,26 +1215,26 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPa { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (void* hBitmapPtr = &hBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1242,14 +1242,14 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPa { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1257,14 +1257,14 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T { fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1274,7 +1274,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); } } } @@ -2512,7 +2512,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2520,7 +2520,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2528,7 +2528,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2536,7 +2536,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2544,7 +2544,7 @@ public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.Fl } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2552,7 +2552,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2560,7 +2560,7 @@ public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.Fl } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2568,7 +2568,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStrea } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2576,7 +2576,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [F } /// To be documented. - public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2584,7 +2584,7 @@ public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flo } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2592,7 +2592,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [F } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2600,7 +2600,7 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32E } /// To be documented. - public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2608,7 +2608,7 @@ public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.I } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2616,7 +2616,7 @@ public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(S } /// To be documented. - public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2773,7 +2773,7 @@ public readonly int CreateColorTransformer(ref ComPtr ppIWICColorTrans } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2781,7 +2781,7 @@ public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* } /// To be documented. - public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2789,7 +2789,7 @@ public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixe } /// To be documented. - public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2797,7 +2797,7 @@ public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2805,7 +2805,7 @@ public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSourc } /// To be documented. - public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2885,7 +2885,7 @@ public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2893,7 +2893,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPa } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2901,7 +2901,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2909,7 +2909,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void } /// To be documented. - public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICComponentFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs index 29467fa8f6..b841a19f4e 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICComponentInfo.gen.cs @@ -111,22 +111,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICComponentInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs index 35b077c23e..b6374c1b08 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsDecoder.gen.cs @@ -111,22 +111,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetParameters(WICDdsParameters* pParameters) + public readonly unsafe int GetParameters(DdsParameters* pParameters) { var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); return ret; } /// To be documented. - public readonly int GetParameters(ref WICDdsParameters pParameters) + public readonly int GetParameters(ref DdsParameters pParameters) { var @this = (IWICDdsDecoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICDdsParameters* pParametersPtr = &pParameters) + fixed (DdsParameters* pParametersPtr = &pParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs index f12cb43170..a7e059adb0 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsEncoder.gen.cs @@ -111,43 +111,43 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int SetParameters(WICDdsParameters* pParameters) + public readonly unsafe int SetParameters(DdsParameters* pParameters) { var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); return ret; } /// To be documented. - public readonly int SetParameters(ref WICDdsParameters pParameters) + public readonly int SetParameters(ref DdsParameters pParameters) { var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICDdsParameters* pParametersPtr = &pParameters) + fixed (DdsParameters* pParametersPtr = &pParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); } return ret; } /// To be documented. - public readonly unsafe int GetParameters(WICDdsParameters* pParameters) + public readonly unsafe int GetParameters(DdsParameters* pParameters) { var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParameters); return ret; } /// To be documented. - public readonly int GetParameters(ref WICDdsParameters pParameters) + public readonly int GetParameters(ref DdsParameters pParameters) { var @this = (IWICDdsEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICDdsParameters* pParametersPtr = &pParameters) + fixed (DdsParameters* pParametersPtr = &pParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParametersPtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs index f697fe1e3d..aea710745b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs @@ -159,94 +159,94 @@ public readonly int GetSizeInBlocks(ref uint pWidthInBlocks, ref uint pHeightInB } /// To be documented. - public readonly unsafe int GetFormatInfo(WICDdsFormatInfo* pFormatInfo) + public readonly unsafe int GetFormatInfo(DdsFormatInfo* pFormatInfo) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfo); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfo); return ret; } /// To be documented. - public readonly int GetFormatInfo(ref WICDdsFormatInfo pFormatInfo) + public readonly int GetFormatInfo(ref DdsFormatInfo pFormatInfo) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICDdsFormatInfo* pFormatInfoPtr = &pFormatInfo) + fixed (DdsFormatInfo* pFormatInfoPtr = &pFormatInfo) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfoPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfoPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs index ca28b7c8e5..cecd63c68f 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs @@ -255,73 +255,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -418,32 +418,32 @@ public readonly unsafe int GetThumbnail(ref IWICBitmapSource* ppIThumbnail) } /// To be documented. - public readonly unsafe int QueryRawCapabilitiesInfo(WICRawCapabilitiesInfo* pInfo) + public readonly unsafe int QueryRawCapabilitiesInfo(RawCapabilitiesInfo* pInfo) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfo); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfo); return ret; } /// To be documented. - public readonly int QueryRawCapabilitiesInfo(ref WICRawCapabilitiesInfo pInfo) + public readonly int QueryRawCapabilitiesInfo(ref RawCapabilitiesInfo pInfo) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRawCapabilitiesInfo* pInfoPtr = &pInfo) + fixed (RawCapabilitiesInfo* pInfoPtr = &pInfo) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfoPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfoPtr); } return ret; } /// To be documented. - public readonly int LoadParameterSet(WICRawParameterSet ParameterSet) + public readonly int LoadParameterSet(RawParameterSet ParameterSet) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ParameterSet); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ParameterSet); return ret; } @@ -616,31 +616,31 @@ public readonly int GetWhitePointRGB(ref uint pRed, ref uint pGreen, ref uint pB } /// To be documented. - public readonly int SetNamedWhitePoint(WICNamedWhitePoint WhitePoint) + public readonly int SetNamedWhitePoint(NamedWhitePoint WhitePoint) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, WhitePoint); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, WhitePoint); return ret; } /// To be documented. - public readonly unsafe int GetNamedWhitePoint(WICNamedWhitePoint* pWhitePoint) + public readonly unsafe int GetNamedWhitePoint(NamedWhitePoint* pWhitePoint) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePoint); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePoint); return ret; } /// To be documented. - public readonly int GetNamedWhitePoint(ref WICNamedWhitePoint pWhitePoint) + public readonly int GetNamedWhitePoint(ref NamedWhitePoint pWhitePoint) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICNamedWhitePoint* pWhitePointPtr = &pWhitePoint) + fixed (NamedWhitePoint* pWhitePointPtr = &pWhitePoint) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePointPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePointPtr); } return ret; } @@ -985,69 +985,69 @@ public readonly int SetDestinationColorContext(ref IWICColorContext pColorContex } /// To be documented. - public readonly unsafe int SetToneCurve(uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) + public readonly unsafe int SetToneCurve(uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurve* pToneCurve) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurve); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurve); return ret; } /// To be documented. - public readonly int SetToneCurve(uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve) + public readonly int SetToneCurve(uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurve pToneCurve) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + fixed (RawToneCurve* pToneCurvePtr = &pToneCurve) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurvePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurvePtr); } return ret; } /// To be documented. - public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); return ret; } /// To be documented. - public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) + public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSizePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSizePtr); } return ret; } /// To be documented. - public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) + public readonly unsafe int GetToneCurve(uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + fixed (RawToneCurve* pToneCurvePtr = &pToneCurve) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSize); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSize); } return ret; } /// To be documented. - public readonly int GetToneCurve(uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) + public readonly int GetToneCurve(uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + fixed (RawToneCurve* pToneCurvePtr = &pToneCurve) { fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSizePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSizePtr); } } return ret; @@ -1084,31 +1084,31 @@ public readonly int GetRotation(ref double pRotation) } /// To be documented. - public readonly int SetRenderMode(WICRawRenderMode RenderMode) + public readonly int SetRenderMode(RawRenderMode RenderMode) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[40])(@this, RenderMode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[40])(@this, RenderMode); return ret; } /// To be documented. - public readonly unsafe int GetRenderMode(WICRawRenderMode* pRenderMode) + public readonly unsafe int GetRenderMode(RawRenderMode* pRenderMode) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderMode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderMode); return ret; } /// To be documented. - public readonly int GetRenderMode(ref WICRawRenderMode pRenderMode) + public readonly int GetRenderMode(ref RawRenderMode pRenderMode) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRawRenderMode* pRenderModePtr = &pRenderMode) + fixed (RawRenderMode* pRenderModePtr = &pRenderMode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderModePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderModePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs index 091371ddaa..ef01482926 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs @@ -252,113 +252,113 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -366,26 +366,26 @@ public readonly unsafe int Initialize(IWICBitmapSource* pISource, ref Guid dstFo { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -393,14 +393,14 @@ public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFo { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -408,14 +408,14 @@ public readonly unsafe int Initialize(ref IWICBitmapSource pISource, ref Guid ds { fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -425,7 +425,7 @@ public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } } @@ -558,7 +558,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -566,7 +566,7 @@ public readonly unsafe int Initialize(ComPtr pISource, Guid* dstF } /// To be documented. - public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -574,7 +574,7 @@ public readonly unsafe int Initialize(ComPtr pISource, Guid* dstFormat } /// To be documented. - public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -582,7 +582,7 @@ public readonly int Initialize(ComPtr pISource, ref Guid dstForma } /// To be documented. - public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -590,7 +590,7 @@ public readonly int Initialize(ComPtr pISource, ref Guid dstFormat, WI } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -598,7 +598,7 @@ public readonly unsafe int Initialize(ref IWICBitmapSource pISource, Guid* } /// To be documented. - public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ref IWICBitmapSource pISource, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs index 9ce8188f8a..61627361a5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverterInfo.gen.cs @@ -114,22 +114,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICFormatConverterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs index 1e3fa62578..44543cc664 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImageEncoder.gen.cs @@ -111,82 +111,82 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParameters); return ret; } /// To be documented. - public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParametersPtr); } return ret; } /// To be documented. - public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParameters); } return ret; } /// To be documented. - public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); } } return ret; } /// To be documented. - public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParameters); } return ret; } /// To be documented. - public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); } } return ret; } /// To be documented. - public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -194,14 +194,14 @@ public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, r { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); } } return ret; } /// To be documented. - public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -209,9 +209,9 @@ public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWIC { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); } } } @@ -219,82 +219,82 @@ public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWIC } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParameters); return ret; } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParametersPtr); } return ret; } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParameters); } return ret; } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); } } return ret; } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParameters); } return ret; } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); } } return ret; } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -302,14 +302,14 @@ public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); } } return ret; } /// To be documented. - public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -317,9 +317,9 @@ public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); } } } @@ -327,82 +327,82 @@ public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, } /// To be documented. - public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParameters); return ret; } /// To be documented. - public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParametersPtr); } return ret; } /// To be documented. - public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParameters); } return ret; } /// To be documented. - public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParametersPtr); } } return ret; } /// To be documented. - public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParameters); } return ret; } /// To be documented. - public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParametersPtr); } } return ret; } /// To be documented. - public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -410,14 +410,14 @@ public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImag { fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParameters); } } return ret; } /// To be documented. - public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -425,9 +425,9 @@ public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ref { fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParametersPtr); } } } @@ -444,7 +444,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -452,7 +452,7 @@ public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, } /// To be documented. - public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -460,7 +460,7 @@ public readonly unsafe int WriteFrame(Silk.NET.Direct2D.ID2D1Image* pImage, } /// To be documented. - public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -468,7 +468,7 @@ public readonly unsafe int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pIma } /// To be documented. - public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -476,7 +476,7 @@ public readonly int WriteFrame(ref Silk.NET.Direct2D.ID2D1Image pImage, Com } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -484,7 +484,7 @@ public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -492,7 +492,7 @@ public readonly unsafe int WriteFrameThumbnail(Silk.NET.Direct2D.ID2D1Image } /// To be documented. - public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -500,7 +500,7 @@ public readonly unsafe int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1I } /// To be documented. - public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -508,7 +508,7 @@ public readonly int WriteFrameThumbnail(ref Silk.NET.Direct2D.ID2D1Image pI } /// To be documented. - public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -516,7 +516,7 @@ public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pIm } /// To be documented. - public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -524,7 +524,7 @@ public readonly unsafe int WriteThumbnail(Silk.NET.Direct2D.ID2D1Image* pIm } /// To be documented. - public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -532,7 +532,7 @@ public readonly unsafe int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image } /// To be documented. - public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteThumbnail(ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImageEncoder*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs index 19e2d36630..3384ff36cd 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory.gen.cs @@ -111,40 +111,40 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -152,26 +152,26 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzFilenamePtr = &wzFilename) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -179,14 +179,14 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -194,14 +194,14 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -211,7 +211,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } } @@ -219,46 +219,46 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -267,7 +267,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } SilkMarshal.Free((nint)wzFilenamePtr); @@ -275,40 +275,40 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -316,26 +316,26 @@ public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.ISt { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -343,14 +343,14 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -358,14 +358,14 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -375,7 +375,7 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } } @@ -383,40 +383,40 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -424,7 +424,7 @@ public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.N { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; @@ -863,40 +863,40 @@ public readonly unsafe int CreateColorTransformer(ref IWICColorTransform* ppIWIC } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pixelFormatPtr = &pixelFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -904,47 +904,47 @@ public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pi { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -952,7 +952,7 @@ public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapS { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); } } return ret; @@ -1171,40 +1171,40 @@ public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, r } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1212,26 +1212,26 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPa { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (void* hBitmapPtr = &hBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1239,14 +1239,14 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPa { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1254,14 +1254,14 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T { fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1271,7 +1271,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); } } } @@ -1669,7 +1669,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1677,7 +1677,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1685,7 +1685,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1693,7 +1693,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1701,7 +1701,7 @@ public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.Fl } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1709,7 +1709,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1717,7 +1717,7 @@ public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.Fl } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1725,7 +1725,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStrea } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1733,7 +1733,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [F } /// To be documented. - public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1741,7 +1741,7 @@ public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flo } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1749,7 +1749,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [F } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1757,7 +1757,7 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32E } /// To be documented. - public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1765,7 +1765,7 @@ public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.I } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1773,7 +1773,7 @@ public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(S } /// To be documented. - public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1930,7 +1930,7 @@ public readonly int CreateColorTransformer(ref ComPtr ppIWICColorTrans } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1938,7 +1938,7 @@ public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* } /// To be documented. - public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1946,7 +1946,7 @@ public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixe } /// To be documented. - public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1954,7 +1954,7 @@ public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1962,7 +1962,7 @@ public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSourc } /// To be documented. - public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2042,7 +2042,7 @@ public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2050,7 +2050,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPa } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2058,7 +2058,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2066,7 +2066,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void } /// To be documented. - public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs index 4742ea8b23..fc8a07c296 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICImagingFactory2.gen.cs @@ -114,40 +114,40 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -155,26 +155,26 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (char* wzFilenamePtr = &wzFilename) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -182,14 +182,14 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -197,14 +197,14 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -214,7 +214,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } } @@ -222,46 +222,46 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -270,7 +270,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } SilkMarshal.Free((nint)wzFilenamePtr); @@ -278,40 +278,40 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native. } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -319,26 +319,26 @@ public readonly unsafe int CreateDecoderFromStream(Silk.NET.Core.Win32Extras.ISt { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -346,14 +346,14 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -361,14 +361,14 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -378,7 +378,7 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } } @@ -386,40 +386,40 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -427,7 +427,7 @@ public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.N { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; @@ -866,40 +866,40 @@ public readonly unsafe int CreateColorTransformer(ref IWICColorTransform* ppIWIC } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pixelFormatPtr = &pixelFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -907,47 +907,47 @@ public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pi { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -955,7 +955,7 @@ public readonly unsafe int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapS { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); } } return ret; @@ -1174,40 +1174,40 @@ public readonly unsafe int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, r } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1215,26 +1215,26 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPa { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (void* hBitmapPtr = &hBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1242,14 +1242,14 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPa { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1257,14 +1257,14 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T { fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); } } return ret; } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -1274,7 +1274,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); } } } @@ -1720,7 +1720,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1728,7 +1728,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1736,7 +1736,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1744,7 +1744,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1752,7 +1752,7 @@ public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.Fl } /// To be documented. - public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1760,7 +1760,7 @@ public readonly unsafe int CreateDecoderFromFilename([Flow(Silk.NET.Core.Na } /// To be documented. - public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1768,7 +1768,7 @@ public readonly int CreateDecoderFromFilename([Flow(Silk.NET.Core.Native.Fl } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1776,7 +1776,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStrea } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1784,7 +1784,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [F } /// To be documented. - public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1792,7 +1792,7 @@ public readonly int CreateDecoderFromStream(ComPtr pIStream, [Flo } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1800,7 +1800,7 @@ public readonly unsafe int CreateDecoderFromStream(ComPtr pIStream, [F } /// To be documented. - public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1808,7 +1808,7 @@ public readonly unsafe int CreateDecoderFromStream(ref Silk.NET.Core.Win32E } /// To be documented. - public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1816,7 +1816,7 @@ public readonly int CreateDecoderFromStream(ref Silk.NET.Core.Win32Extras.I } /// To be documented. - public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1824,7 +1824,7 @@ public readonly unsafe int CreateDecoderFromFileHandle(nuint hFile, [Flow(S } /// To be documented. - public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateDecoderFromFileHandle(nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1981,7 +1981,7 @@ public readonly int CreateColorTransformer(ref ComPtr ppIWICColorTrans } /// To be documented. - public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1989,7 +1989,7 @@ public readonly unsafe int CreateBitmap(uint uiWidth, uint uiHeight, Guid* } /// To be documented. - public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -1997,7 +1997,7 @@ public readonly int CreateBitmap(uint uiWidth, uint uiHeight, ref Guid pixe } /// To be documented. - public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2005,7 +2005,7 @@ public readonly int CreateBitmapFromSource(ComPtr pIBitmapSource, } /// To be documented. - public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2013,7 +2013,7 @@ public readonly unsafe int CreateBitmapFromSource(ComPtr pIBitmapSourc } /// To be documented. - public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromSource(ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2093,7 +2093,7 @@ public readonly int CreateBitmapFromMemory(uint uiWidth, uint uiHeight, ref } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2101,7 +2101,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, void* hPa } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2109,7 +2109,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(void* hBitmap, ref T } /// To be documented. - public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -2117,7 +2117,7 @@ public readonly unsafe int CreateBitmapFromHBITMAP(ref T0 hBitmap, void } /// To be documented. - public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int CreateBitmapFromHBITMAP(ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICImagingFactory2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs index 68049993a4..27511d4235 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICJpegFrameDecode.gen.cs @@ -132,11 +132,11 @@ public readonly int DoesSupportIndexing(ref int pfIndexingSupported) } /// To be documented. - public readonly int SetIndexing(WICJpegIndexingOptions options, uint horizontalIntervalSize) + public readonly int SetIndexing(JpegIndexingOptions options, uint horizontalIntervalSize) { var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, options, horizontalIntervalSize); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, options, horizontalIntervalSize); return ret; } @@ -213,43 +213,43 @@ public readonly int GetQuantizationTable(uint scanIndex, uint tableIndex, ref Si } /// To be documented. - public readonly unsafe int GetFrameHeader(WICJpegFrameHeader* pFrameHeader) + public readonly unsafe int GetFrameHeader(JpegFrameHeader* pFrameHeader) { var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeader); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeader); return ret; } /// To be documented. - public readonly int GetFrameHeader(ref WICJpegFrameHeader pFrameHeader) + public readonly int GetFrameHeader(ref JpegFrameHeader pFrameHeader) { var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICJpegFrameHeader* pFrameHeaderPtr = &pFrameHeader) + fixed (JpegFrameHeader* pFrameHeaderPtr = &pFrameHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeaderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeaderPtr); } return ret; } /// To be documented. - public readonly unsafe int GetScanHeader(uint scanIndex, WICJpegScanHeader* pScanHeader) + public readonly unsafe int GetScanHeader(uint scanIndex, JpegScanHeader* pScanHeader) { var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeader); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeader); return ret; } /// To be documented. - public readonly int GetScanHeader(uint scanIndex, ref WICJpegScanHeader pScanHeader) + public readonly int GetScanHeader(uint scanIndex, ref JpegScanHeader pScanHeader) { var @this = (IWICJpegFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICJpegScanHeader* pScanHeaderPtr = &pScanHeader) + fixed (JpegScanHeader* pScanHeaderPtr = &pScanHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeaderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeaderPtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs index f26b632459..d6e8840661 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataHandlerInfo.gen.cs @@ -114,22 +114,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICMetadataHandlerInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs index 48d7fd469a..96dfd1b3b4 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataReaderInfo.gen.cs @@ -117,22 +117,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -771,40 +771,40 @@ public readonly int DoesRequireFixedSize(ref int pfFixedSize) } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActualPtr); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActual); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -812,66 +812,66 @@ public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, W { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActual); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActual); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); } } } @@ -879,19 +879,19 @@ public readonly unsafe int GetPatterns(Guid* guidContainerFormat, uint cbSize, r } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActual); } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -899,14 +899,14 @@ public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -914,14 +914,14 @@ public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize { fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActual); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -931,7 +931,7 @@ public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActualPtr); } } } @@ -939,32 +939,32 @@ public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActual); } } return ret; } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActualPtr); } } } @@ -972,17 +972,17 @@ public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize } /// To be documented. - public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActual); } } } @@ -990,19 +990,19 @@ public readonly unsafe int GetPatterns(ref Guid guidContainerFormat, uint cbSize } /// To be documented. - public readonly int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + public readonly int GetPatterns(ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) { var @this = (IWICMetadataReaderInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); } } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs index d2341adb5c..a678973c60 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICMetadataWriterInfo.gen.cs @@ -117,22 +117,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -771,67 +771,67 @@ public readonly int DoesRequireFixedSize(ref int pfFixedSize) } /// To be documented. - public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActual); return ret; } /// To be documented. - public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActualPtr); } return ret; } /// To be documented. - public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActual); } return ret; } /// To be documented. - public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + public readonly unsafe int GetHeader(Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActual); } return ret; } /// To be documented. - public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -839,39 +839,39 @@ public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActualPtr); } } return ret; } /// To be documented. - public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + public readonly unsafe int GetHeader(ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActual); } } return ret; } /// To be documented. - public readonly int GetHeader(ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + public readonly int GetHeader(ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual) { var @this = (IWICMetadataWriterInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActualPtr); } } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs index 3f306f6a63..4bca751816 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPalette.gen.cs @@ -111,11 +111,11 @@ public readonly uint Release() } /// To be documented. - public readonly int InitializePredefined(WICBitmapPaletteType ePaletteType, Silk.NET.Core.Bool32 fAddTransparentColor) + public readonly int InitializePredefined(BitmapPaletteType ePaletteType, Silk.NET.Core.Bool32 fAddTransparentColor) { var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ePaletteType, fAddTransparentColor); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ePaletteType, fAddTransparentColor); return ret; } @@ -183,22 +183,22 @@ public readonly int InitializeFromPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int GetType(WICBitmapPaletteType* pePaletteType) + public readonly unsafe int GetType(BitmapPaletteType* pePaletteType) { var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteType); return ret; } /// To be documented. - public readonly int GetType(ref WICBitmapPaletteType pePaletteType) + public readonly int GetType(ref BitmapPaletteType pePaletteType) { var @this = (IWICPalette*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPaletteType* pePaletteTypePtr = &pePaletteType) + fixed (BitmapPaletteType* pePaletteTypePtr = &pePaletteType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs index eb6cefe49c..0010721e3c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo.gen.cs @@ -114,22 +114,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICPixelFormatInfo*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs index 6ed29c5a20..84c819b7f0 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPixelFormatInfo2.gen.cs @@ -117,22 +117,22 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int GetComponentType(WICComponentType* pType) + public readonly unsafe int GetComponentType(ComponentType* pType) { var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public readonly int GetComponentType(ref WICComponentType pType) + public readonly int GetComponentType(ref ComponentType pType) { var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -671,22 +671,22 @@ public readonly int SupportsTransparency(ref int pfSupportsTransparency) } /// To be documented. - public readonly unsafe int GetNumericRepresentation(WICPixelFormatNumericRepresentation* pNumericRepresentation) + public readonly unsafe int GetNumericRepresentation(PixelFormatNumericRepresentation* pNumericRepresentation) { var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentation); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentation); return ret; } /// To be documented. - public readonly int GetNumericRepresentation(ref WICPixelFormatNumericRepresentation pNumericRepresentation) + public readonly int GetNumericRepresentation(ref PixelFormatNumericRepresentation pNumericRepresentation) { var @this = (IWICPixelFormatInfo2*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICPixelFormatNumericRepresentation* pNumericRepresentationPtr = &pNumericRepresentation) + fixed (PixelFormatNumericRepresentation* pNumericRepresentationPtr = &pNumericRepresentation) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentationPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentationPtr); } return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs index 05b08cdd28..67e7a1538a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs @@ -111,69 +111,69 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int WritePixels(uint lineCount, WICBitmapPlane* pPlanes, uint cPlanes) + public readonly unsafe int WritePixels(uint lineCount, BitmapPlane* pPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanes, cPlanes); return ret; } /// To be documented. - public readonly int WritePixels(uint lineCount, ref WICBitmapPlane pPlanes, uint cPlanes) + public readonly int WritePixels(uint lineCount, ref BitmapPlane pPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPlane* pPlanesPtr = &pPlanes) + fixed (BitmapPlane* pPlanesPtr = &pPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanesPtr, cPlanes); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, WICRect* prcSource) + public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, Rect* prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); return ret; } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, ref WICRect prcSource) + public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, ref Rect prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, WICRect* prcSource) + public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, Rect* prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref WICRect prcSource) + public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Rect prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); } } return ret; @@ -189,7 +189,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlanes, WICRect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlanes, Rect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -197,7 +197,7 @@ public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlan } /// To be documented. - public readonly int WriteSource(ref ComPtr ppPlanes, uint cPlanes, ref WICRect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteSource(ref ComPtr ppPlanes, uint cPlanes, ref Rect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs index cc2e828d14..b5dc9bbf50 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs @@ -111,67 +111,67 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -179,39 +179,39 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -219,19 +219,19 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, uint* puiHeight, } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* puiHeightPtr = &puiHeight) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -239,39 +239,39 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* puiHeightPtr = &puiHeight) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* puiHeightPtr = &puiHeight) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -279,7 +279,7 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -287,14 +287,14 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -304,7 +304,7 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -312,7 +312,7 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -320,9 +320,9 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -330,7 +330,7 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -338,11 +338,11 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -351,19 +351,19 @@ public readonly unsafe int DoesSupportTransform(uint* puiWidth, ref uint puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* puiWidthPtr = &puiWidth) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -371,39 +371,39 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* puiWidthPtr = &puiWidth) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (uint* puiWidthPtr = &puiWidth) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -411,7 +411,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -419,14 +419,14 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -436,7 +436,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -444,7 +444,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -452,9 +452,9 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -462,7 +462,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -470,11 +470,11 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -483,7 +483,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, uint* puiHeig } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -491,14 +491,14 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (uint* puiHeightPtr = &puiHeight) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -508,7 +508,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -516,7 +516,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -524,9 +524,9 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (uint* puiHeightPtr = &puiHeight) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -534,7 +534,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -542,11 +542,11 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (uint* puiHeightPtr = &puiHeight) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -555,7 +555,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -565,7 +565,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } } } @@ -573,7 +573,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -585,7 +585,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -594,7 +594,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH } /// To be documented. - public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -604,9 +604,9 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -615,7 +615,7 @@ public readonly unsafe int DoesSupportTransform(ref uint puiWidth, ref uint puiH } /// To be documented. - public readonly int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public readonly int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -625,11 +625,11 @@ public readonly int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, { fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -639,48 +639,48 @@ public readonly int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs index c5a940566b..74dab46f33 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs @@ -252,113 +252,113 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -366,26 +366,26 @@ public readonly unsafe int Initialize(IWICBitmapSource** ppPlanes, uint cPlanes, { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -393,14 +393,14 @@ public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlan { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -408,14 +408,14 @@ public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlan { fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -425,7 +425,7 @@ public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlan { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } } @@ -558,7 +558,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -566,7 +566,7 @@ public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint c } /// To be documented. - public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -574,7 +574,7 @@ public readonly unsafe int Initialize(ref ComPtr ppPlanes, uint cPlane } /// To be documented. - public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -582,7 +582,7 @@ public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, } /// To be documented. - public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -590,7 +590,7 @@ public readonly int Initialize(ref ComPtr ppPlanes, uint cPlanes, ref } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -598,7 +598,7 @@ public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs index 3639e505ae..0c8974f7e1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICProgressCallback.gen.cs @@ -111,11 +111,11 @@ public readonly uint Release() } /// To be documented. - public readonly int Notify(uint uFrameNum, WICProgressOperation operation, double dblProgress) + public readonly int Notify(uint uFrameNum, ProgressOperation operation, double dblProgress) { var @this = (IWICProgressCallback*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, uFrameNum, operation, dblProgress); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, uFrameNum, operation, dblProgress); return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/ImageParameters.gen.cs similarity index 96% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/ImageParameters.gen.cs index 34585ade64..34bd572dc6 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageParameters.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/ImageParameters.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICImageParameters")] - public unsafe partial struct WICImageParameters + public unsafe partial struct ImageParameters { - public WICImageParameters + public ImageParameters ( Silk.NET.Direct2D.PixelFormat? pixelFormat = null, float? dpiX = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/JpegFrameHeader.gen.cs similarity index 91% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/JpegFrameHeader.gen.cs index 8e2aca1e85..254c6049d3 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameHeader.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/JpegFrameHeader.gen.cs @@ -17,14 +17,14 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegFrameHeader")] - public unsafe partial struct WICJpegFrameHeader + public unsafe partial struct JpegFrameHeader { - public WICJpegFrameHeader + public JpegFrameHeader ( uint? width = null, uint? height = null, - WICJpegTransferMatrix? transferMatrix = null, - WICJpegScanType? scanType = null, + JpegTransferMatrix? transferMatrix = null, + JpegScanType? scanType = null, uint? cComponents = null, uint? componentIdentifiers = null, uint? sampleFactors = null, @@ -86,12 +86,12 @@ public WICJpegFrameHeader [NativeName("Type", "WICJpegTransferMatrix")] [NativeName("Type.Name", "WICJpegTransferMatrix")] [NativeName("Name", "TransferMatrix")] - public WICJpegTransferMatrix TransferMatrix; + public JpegTransferMatrix TransferMatrix; [NativeName("Type", "WICJpegScanType")] [NativeName("Type.Name", "WICJpegScanType")] [NativeName("Name", "ScanType")] - public WICJpegScanType ScanType; + public JpegScanType ScanType; [NativeName("Type", "UINT")] [NativeName("Type.Name", "UINT")] diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/JpegScanHeader.gen.cs similarity index 97% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/JpegScanHeader.gen.cs index 5af9f7f5e3..3d94713c93 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegScanHeader.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/JpegScanHeader.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICJpegScanHeader")] - public unsafe partial struct WICJpegScanHeader + public unsafe partial struct JpegScanHeader { - public WICJpegScanHeader + public JpegScanHeader ( uint? cComponents = null, uint? restartInterval = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/MetadataHeader.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/MetadataHeader.gen.cs index b2116eae43..34dfe92db3 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHeader.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/MetadataHeader.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICMetadataHeader")] - public unsafe partial struct WICMetadataHeader + public unsafe partial struct MetadataHeader { - public WICMetadataHeader + public MetadataHeader ( ulong? position = null, uint? length = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/MetadataPattern.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/MetadataPattern.gen.cs index 9c646f64d4..7afa9bb9fc 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataPattern.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/MetadataPattern.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICMetadataPattern")] - public unsafe partial struct WICMetadataPattern + public unsafe partial struct MetadataPattern { - public WICMetadataPattern + public MetadataPattern ( ulong? position = null, uint? length = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs index 2bf553a952..266a636a41 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/PfnProgressNotification.gen.cs @@ -19,10 +19,10 @@ namespace Silk.NET.WindowsCodecs public unsafe readonly struct PfnProgressNotification : IDisposable { private readonly void* _handle; - public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; + public delegate* unmanaged[Cdecl] Handle => (delegate* unmanaged[Cdecl]) _handle; public PfnProgressNotification ( - delegate* unmanaged[Cdecl] ptr + delegate* unmanaged[Cdecl] ptr ) => _handle = ptr; public PfnProgressNotification @@ -35,7 +35,7 @@ ProgressNotification proc public static implicit operator nint(PfnProgressNotification pfn) => (nint) pfn.Handle; public static explicit operator PfnProgressNotification(nint pfn) - => new PfnProgressNotification((delegate* unmanaged[Cdecl]) pfn); + => new PfnProgressNotification((delegate* unmanaged[Cdecl]) pfn); public static implicit operator PfnProgressNotification(ProgressNotification proc) => new PfnProgressNotification(proc); @@ -43,11 +43,11 @@ public static implicit operator PfnProgressNotification(ProgressNotification pro public static explicit operator ProgressNotification(PfnProgressNotification pfn) => SilkMarshal.PtrToDelegate(pfn); - public static implicit operator delegate* unmanaged[Cdecl](PfnProgressNotification pfn) => pfn.Handle; - public static implicit operator PfnProgressNotification(delegate* unmanaged[Cdecl] ptr) => new PfnProgressNotification(ptr); + public static implicit operator delegate* unmanaged[Cdecl](PfnProgressNotification pfn) => pfn.Handle; + public static implicit operator PfnProgressNotification(delegate* unmanaged[Cdecl] ptr) => new PfnProgressNotification(ptr); } [UnmanagedFunctionPointer(CallingConvention.Cdecl)] - public unsafe delegate int ProgressNotification(void* arg0, uint arg1, WICProgressOperation arg2, double arg3); + public unsafe delegate int ProgressNotification(void* arg0, uint arg1, ProgressOperation arg2, double arg3); } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawCapabilitiesInfo.gen.cs similarity index 78% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawCapabilitiesInfo.gen.cs index 6e2c45cdda..84d69c6426 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawCapabilitiesInfo.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawCapabilitiesInfo.gen.cs @@ -17,28 +17,28 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawCapabilitiesInfo")] - public unsafe partial struct WICRawCapabilitiesInfo + public unsafe partial struct RawCapabilitiesInfo { - public WICRawCapabilitiesInfo + public RawCapabilitiesInfo ( uint? cbSize = null, uint? codecMajorVersion = null, uint? codecMinorVersion = null, - WICRawCapabilities? exposureCompensationSupport = null, - WICRawCapabilities? contrastSupport = null, - WICRawCapabilities? rGBWhitePointSupport = null, - WICRawCapabilities? namedWhitePointSupport = null, + RawCapabilities? exposureCompensationSupport = null, + RawCapabilities? contrastSupport = null, + RawCapabilities? rGBWhitePointSupport = null, + RawCapabilities? namedWhitePointSupport = null, uint? namedWhitePointSupportMask = null, - WICRawCapabilities? kelvinWhitePointSupport = null, - WICRawCapabilities? gammaSupport = null, - WICRawCapabilities? tintSupport = null, - WICRawCapabilities? saturationSupport = null, - WICRawCapabilities? sharpnessSupport = null, - WICRawCapabilities? noiseReductionSupport = null, - WICRawCapabilities? destinationColorProfileSupport = null, - WICRawCapabilities? toneCurveSupport = null, - WICRawRotationCapabilities? rotationSupport = null, - WICRawCapabilities? renderModeSupport = null + RawCapabilities? kelvinWhitePointSupport = null, + RawCapabilities? gammaSupport = null, + RawCapabilities? tintSupport = null, + RawCapabilities? saturationSupport = null, + RawCapabilities? sharpnessSupport = null, + RawCapabilities? noiseReductionSupport = null, + RawCapabilities? destinationColorProfileSupport = null, + RawCapabilities? toneCurveSupport = null, + RawRotationCapabilities? rotationSupport = null, + RawCapabilities? renderModeSupport = null ) : this() { if (cbSize is not null) @@ -151,22 +151,22 @@ public WICRawCapabilitiesInfo [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "ExposureCompensationSupport")] - public WICRawCapabilities ExposureCompensationSupport; + public RawCapabilities ExposureCompensationSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "ContrastSupport")] - public WICRawCapabilities ContrastSupport; + public RawCapabilities ContrastSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "RGBWhitePointSupport")] - public WICRawCapabilities RGBWhitePointSupport; + public RawCapabilities RGBWhitePointSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "NamedWhitePointSupport")] - public WICRawCapabilities NamedWhitePointSupport; + public RawCapabilities NamedWhitePointSupport; [NativeName("Type", "UINT")] [NativeName("Type.Name", "UINT")] @@ -176,51 +176,51 @@ public WICRawCapabilitiesInfo [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "KelvinWhitePointSupport")] - public WICRawCapabilities KelvinWhitePointSupport; + public RawCapabilities KelvinWhitePointSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "GammaSupport")] - public WICRawCapabilities GammaSupport; + public RawCapabilities GammaSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "TintSupport")] - public WICRawCapabilities TintSupport; + public RawCapabilities TintSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "SaturationSupport")] - public WICRawCapabilities SaturationSupport; + public RawCapabilities SaturationSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "SharpnessSupport")] - public WICRawCapabilities SharpnessSupport; + public RawCapabilities SharpnessSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "NoiseReductionSupport")] - public WICRawCapabilities NoiseReductionSupport; + public RawCapabilities NoiseReductionSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "DestinationColorProfileSupport")] - public WICRawCapabilities DestinationColorProfileSupport; + public RawCapabilities DestinationColorProfileSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "ToneCurveSupport")] - public WICRawCapabilities ToneCurveSupport; + public RawCapabilities ToneCurveSupport; [NativeName("Type", "WICRawRotationCapabilities")] [NativeName("Type.Name", "WICRawRotationCapabilities")] [NativeName("Name", "RotationSupport")] - public WICRawRotationCapabilities RotationSupport; + public RawRotationCapabilities RotationSupport; [NativeName("Type", "WICRawCapabilities")] [NativeName("Type.Name", "WICRawCapabilities")] [NativeName("Name", "RenderModeSupport")] - public WICRawCapabilities RenderModeSupport; + public RawCapabilities RenderModeSupport; } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawToneCurve.gen.cs similarity index 83% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawToneCurve.gen.cs index 3515364964..2056d6f546 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurve.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawToneCurve.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawToneCurve")] - public unsafe partial struct WICRawToneCurve + public unsafe partial struct RawToneCurve { - public WICRawToneCurve + public RawToneCurve ( uint? cPoints = null ) : this() @@ -43,8 +43,8 @@ public WICRawToneCurve public struct APointsBuffer { - public WICRawToneCurvePoint Element0; - public ref WICRawToneCurvePoint this[int index] + public RawToneCurvePoint Element0; + public ref RawToneCurvePoint this[int index] { get { @@ -53,7 +53,7 @@ public ref WICRawToneCurvePoint this[int index] throw new ArgumentOutOfRangeException(nameof(index)); } - fixed (WICRawToneCurvePoint* ptr = &Element0) + fixed (RawToneCurvePoint* ptr = &Element0) { return ref ptr[index]; } @@ -61,7 +61,7 @@ public ref WICRawToneCurvePoint this[int index] } #if NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0 || NET5_0_OR_GREATER - public Span AsSpan() + public Span AsSpan() => MemoryMarshal.CreateSpan(ref Element0, 1); #endif } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawToneCurvePoint.gen.cs similarity index 92% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawToneCurvePoint.gen.cs index e075265034..7fe90c89e2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRawToneCurvePoint.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/RawToneCurvePoint.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRawToneCurvePoint")] - public unsafe partial struct WICRawToneCurvePoint + public unsafe partial struct RawToneCurvePoint { - public WICRawToneCurvePoint + public RawToneCurvePoint ( double? input = null, double? output = null diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs similarity index 96% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs index 8a69c586e4..fa6b69c6ce 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICRect.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs @@ -17,9 +17,9 @@ namespace Silk.NET.WindowsCodecs { [NativeName("Name", "WICRect")] - public unsafe partial struct WICRect + public unsafe partial struct Rect { - public WICRect + public Rect ( int? x = null, int? y = null, diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs index c51490f559..0d6b3e69fc 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs @@ -223,121 +223,121 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICP } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); } return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); } } return ret; @@ -441,7 +441,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -449,7 +449,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Fl } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -457,7 +457,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Fl } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -465,7 +465,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -473,7 +473,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -481,7 +481,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -489,7 +489,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, IWI } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -497,7 +497,7 @@ public static int Initialize(this ComPtr thisVtbl, ComPt } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc) + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -505,7 +505,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, Spa } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) + public static int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs index 819c97f417..9d0ffd7cac 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapCodecInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -1077,7 +1077,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtb } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs index 50396fda3f..2cd7cd4bf8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -1052,40 +1052,40 @@ public static int MatchesMimeType(this ComPtr thisVtbl, [ } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActualPtr); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pcPatternsPtr = &pcPatterns) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActual); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; @@ -1093,66 +1093,66 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl { fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatterns, pcPatternsPtr, pcbPatternsActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActual); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatterns, pcbPatternsActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { fixed (uint* pcPatternsPtr = &pcPatterns) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActual); } } return ret; } /// To be documented. - public static int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) + public static int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPattern* pPatternsPtr = &pPatterns) + fixed (BitmapPattern* pPatternsPtr = &pPatterns) { fixed (uint* pcPatternsPtr = &pcPatterns) { fixed (uint* pcbPatternsActualPtr = &pcbPatternsActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[23])(@this, cbSizePatterns, pPatternsPtr, pcPatternsPtr, pcbPatternsActualPtr); } } } @@ -1254,7 +1254,7 @@ public static unsafe int QueryInterface(this ComPtr thisV } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1670,7 +1670,7 @@ public static int MatchesMimeType(this ComPtr thisVtbl, [ } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1678,7 +1678,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1686,7 +1686,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, BitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1694,7 +1694,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1702,7 +1702,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1710,7 +1710,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1718,7 +1718,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtbl } /// To be documented. - public static int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) + public static int GetPatterns(this ComPtr thisVtbl, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs index 85e1b90af0..d46ca009f4 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapDecoderVtblExtensions.gen.cs @@ -133,22 +133,22 @@ public static int QueryCapability(this ComPtr thisVtbl, ref S } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, WICDecodeOptions cacheOptions) + public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, DecodeOptions cacheOptions) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, cacheOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, cacheOptions); return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, WICDecodeOptions cacheOptions) + public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, DecodeOptions cacheOptions) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, cacheOptions); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, cacheOptions); } return ret; } @@ -435,7 +435,7 @@ public static int QueryCapability(this ComPtr thisVtbl, Span< } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pIStream, WICDecodeOptions cacheOptions) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pIStream, DecodeOptions cacheOptions) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -443,7 +443,7 @@ public static int Initialize(this ComPtr thisVtbl, ComPt } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pIStream, WICDecodeOptions cacheOptions) + public static int Initialize(this ComPtr thisVtbl, Span pIStream, DecodeOptions cacheOptions) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs index f3ccfd7eb3..781451a5c8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -1098,7 +1098,7 @@ public static unsafe int QueryInterface(this ComPtr thisV } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs index 3fff445bc9..840e15d526 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapEncoderVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, WICBitmapEncoderCacheOption cacheOption) + public static unsafe int Initialize(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, BitmapEncoderCacheOption cacheOption) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, cacheOption); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStream, cacheOption); return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, WICBitmapEncoderCacheOption cacheOption) + public static int Initialize(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, BitmapEncoderCacheOption cacheOption) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, cacheOption); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pIStreamPtr, cacheOption); } return ret; } @@ -335,7 +335,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pIStream, WICBitmapEncoderCacheOption cacheOption) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pIStream, BitmapEncoderCacheOption cacheOption) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -343,7 +343,7 @@ public static int Initialize(this ComPtr thisVtbl, ComPt } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pIStream, WICBitmapEncoderCacheOption cacheOption) + public static int Initialize(this ComPtr thisVtbl, Span pIStream, BitmapEncoderCacheOption cacheOption) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs index 62b7ad9631..997c177e38 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs @@ -223,95 +223,95 @@ public static int CopyPalette(this ComPtr thisVtbl, ref I } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, WICBitmapTransformOptions options) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, BitmapTransformOptions options) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, options); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, options); return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, WICBitmapTransformOptions options) + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, BitmapTransformOptions options) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, options); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, options); } return ret; } @@ -414,7 +414,7 @@ public static int CopyPalette(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -422,7 +422,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -430,7 +430,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -438,7 +438,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -446,7 +446,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, WICBitmapTransformOptions options) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, BitmapTransformOptions options) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -454,7 +454,7 @@ public static int Initialize(this ComPtr thisVtbl, C } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pISource, WICBitmapTransformOptions options) + public static int Initialize(this ComPtr thisVtbl, Span pISource, BitmapTransformOptions options) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs index b0fd3fea4c..fd80139b08 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref I } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -483,7 +483,7 @@ public static int CopyPalette(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -491,7 +491,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -499,7 +499,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -507,7 +507,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs index 990bb53076..f6b9d218f2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs @@ -240,48 +240,48 @@ public static int WritePixels(this ComPtr thisVtbl, uint } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICRect* prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Rect* prc) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref WICRect prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref Rect prc) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICRect* prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, Rect* prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); } return ret; } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref WICRect prc) + public static int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref Rect prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); } } return ret; @@ -415,7 +415,7 @@ public static int WritePixels(this ComPtr thisVtbl, uint } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICRect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -423,7 +423,7 @@ public static unsafe int WriteSource(this ComPtr thi } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -431,7 +431,7 @@ public static unsafe int WriteSource(this ComPtr thisVtbl } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref WICRect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -439,7 +439,7 @@ public static int WriteSource(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, WICRect* prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Rect* prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -447,7 +447,7 @@ public static unsafe int WriteSource(this ComPtr thisVtbl } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Span prc) + public static int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Span prc) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs index 66442399cc..bc078d12af 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs @@ -223,95 +223,95 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPa } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, uiWidth, uiHeight, mode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, uiWidth, uiHeight, mode); return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, uiWidth, uiHeight, mode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, uiWidth, uiHeight, mode); } return ret; } @@ -414,7 +414,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -422,7 +422,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -430,7 +430,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -438,7 +438,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -446,7 +446,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -454,7 +454,7 @@ public static int Initialize(this ComPtr thisVtbl, ComPtr } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pISource, uint uiWidth, uint uiHeight, WICBitmapInterpolationMode mode) + public static int Initialize(this ComPtr thisVtbl, Span pISource, uint uiWidth, uint uiHeight, BitmapInterpolationMode mode) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs index 0a7ed7bdc0..45147f6bc1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs @@ -85,51 +85,51 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; @@ -137,94 +137,94 @@ public static unsafe int CopyPixels(this ComPtr thisV { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } } @@ -232,16 +232,16 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } } @@ -318,22 +318,22 @@ public static int GetClosestPixelFormat(this ComPtr t } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, WICBitmapTransformOptions dstTransform, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, BitmapTransformOptions dstTransform, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupported); return ret; } /// To be documented. - public static int DoesSupportTransform(this ComPtr thisVtbl, WICBitmapTransformOptions dstTransform, ref int pfIsSupported) + public static int DoesSupportTransform(this ComPtr thisVtbl, BitmapTransformOptions dstTransform, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, dstTransform, pfIsSupportedPtr); } return ret; } @@ -364,7 +364,7 @@ public static unsafe int QueryInterface(this ComPtr t } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -372,7 +372,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -380,7 +380,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -388,7 +388,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -396,7 +396,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -404,7 +404,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -412,7 +412,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -420,7 +420,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -428,7 +428,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -436,7 +436,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, WICBitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -476,7 +476,7 @@ public static int GetClosestPixelFormat(this ComPtr t } /// To be documented. - public static int DoesSupportTransform(this ComPtr thisVtbl, WICBitmapTransformOptions dstTransform, Span pfIsSupported) + public static int DoesSupportTransform(this ComPtr thisVtbl, BitmapTransformOptions dstTransform, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs index ad135b899c..66d7955d98 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPa } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -393,7 +393,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -401,7 +401,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -409,7 +409,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -417,7 +417,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs index 9998f4d24c..9de1ee8064 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs @@ -223,121 +223,121 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, IWICBitmapLock** ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref IWICBitmapLock* ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); } return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, IWICBitmapLock** ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcLockPtr = &prcLock) + fixed (Rect* prcLockPtr = &prcLock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); } return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref IWICBitmapLock* ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcLockPtr = &prcLock) + fixed (Rect* prcLockPtr = &prcLock) { fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); } } return ret; @@ -471,7 +471,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -479,7 +479,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -487,7 +487,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -495,7 +495,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Co } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -503,7 +503,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Co } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -511,7 +511,7 @@ public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, IWICBitmapLock** ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = thisVtbl.Handle; // SpanOverloader @@ -519,7 +519,7 @@ public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.C } /// To be documented. - public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -527,7 +527,7 @@ public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Cor } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, ref IWICBitmapLock* ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs index 4bff878784..b31c61c91e 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorContextVtblExtensions.gen.cs @@ -158,22 +158,22 @@ public static int InitializeFromExifColorSpace(this ComPtr thi } /// To be documented. - public static unsafe int GetType(this ComPtr thisVtbl, WICColorContextType* pType) + public static unsafe int GetType(this ComPtr thisVtbl, ColorContextType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pType); return ret; } /// To be documented. - public static int GetType(this ComPtr thisVtbl, ref WICColorContextType pType) + public static int GetType(this ComPtr thisVtbl, ref ColorContextType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICColorContextType* pTypePtr = &pType) + fixed (ColorContextType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[6])(@this, pTypePtr); } return ret; } @@ -314,7 +314,7 @@ public static int InitializeFromMemory(this ComPtr thisVtbl, [ } /// To be documented. - public static int GetType(this ComPtr thisVtbl, Span pType) + public static int GetType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs index e939a28dba..4cafd1bfc1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWIC } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -633,7 +633,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -641,7 +641,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -649,7 +649,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -657,7 +657,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Sil } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs index e105eb7867..74946903d6 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentFactoryVtblExtensions.gen.cs @@ -85,40 +85,40 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -126,26 +126,26 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzFilenamePtr = &wzFilename) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -153,14 +153,14 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -168,14 +168,14 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -185,7 +185,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } } @@ -193,46 +193,46 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -241,7 +241,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } SilkMarshal.Free((nint)wzFilenamePtr); @@ -249,40 +249,40 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -290,26 +290,26 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -317,14 +317,14 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -332,14 +332,14 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -349,7 +349,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } } @@ -357,40 +357,40 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -398,7 +398,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtr)@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; @@ -837,40 +837,40 @@ public static unsafe int CreateColorTransformer(this ComPtrTo be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pixelFormatPtr = &pixelFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; @@ -878,47 +878,47 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; @@ -926,7 +926,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtr)@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); } } return ret; @@ -1145,40 +1145,40 @@ public static unsafe int CreateBitmapFromMemory(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1186,26 +1186,26 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; fixed (void* hBitmapPtr = &hBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1213,14 +1213,14 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1228,14 +1228,14 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1245,7 +1245,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); } } } @@ -2499,7 +2499,7 @@ public static unsafe int QueryInterface(this ComPtr thisVt } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2507,7 +2507,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2515,7 +2515,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2523,7 +2523,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2531,7 +2531,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2539,7 +2539,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2547,7 +2547,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2555,7 +2555,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2563,7 +2563,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2571,7 +2571,7 @@ public static int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2579,7 +2579,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2587,7 +2587,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2595,7 +2595,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2603,7 +2603,7 @@ public static int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2611,7 +2611,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2619,7 +2619,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2627,7 +2627,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2635,7 +2635,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2643,7 +2643,7 @@ public static int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2651,7 +2651,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2659,7 +2659,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2667,7 +2667,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2675,7 +2675,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2683,7 +2683,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2691,7 +2691,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2699,7 +2699,7 @@ public static int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2707,7 +2707,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2715,7 +2715,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2723,7 +2723,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2731,7 +2731,7 @@ public static int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -3000,7 +3000,7 @@ public static int CreateColorTransformer(this ComPtr } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3008,7 +3008,7 @@ public static unsafe int CreateBitmap(this ComPtr thi } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -3016,7 +3016,7 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl } /// To be documented. - public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3024,7 +3024,7 @@ public static int CreateBitmap(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -3032,7 +3032,7 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl } /// To be documented. - public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3040,7 +3040,7 @@ public static int CreateBitmapFromSource(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3048,7 +3048,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -3056,7 +3056,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtrTo be documented. - public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3064,7 +3064,7 @@ public static int CreateBitmapFromSource(this ComPtr } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -3224,7 +3224,7 @@ public static unsafe int CreateBitmapFromMemory(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3232,7 +3232,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -3240,7 +3240,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3248,7 +3248,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -3256,7 +3256,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -3264,7 +3264,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3272,7 +3272,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -3280,7 +3280,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -3288,7 +3288,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -3296,7 +3296,7 @@ public static int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs index 18ebc5cfe0..9b499149ca 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICComponentInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -486,7 +486,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs index d0e0f2a1b1..cea2ed2f16 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsDecoderVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetParameters(this ComPtr thisVtbl, WICDdsParameters* pParameters) + public static unsafe int GetParameters(this ComPtr thisVtbl, DdsParameters* pParameters) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); return ret; } /// To be documented. - public static int GetParameters(this ComPtr thisVtbl, ref WICDdsParameters pParameters) + public static int GetParameters(this ComPtr thisVtbl, ref DdsParameters pParameters) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICDdsParameters* pParametersPtr = &pParameters) + fixed (DdsParameters* pParametersPtr = &pParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); } return ret; } @@ -152,7 +152,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Sp } /// To be documented. - public static int GetParameters(this ComPtr thisVtbl, Span pParameters) + public static int GetParameters(this ComPtr thisVtbl, Span pParameters) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs index 69617e7a7b..c4f1dd9566 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsEncoderVtblExtensions.gen.cs @@ -85,43 +85,43 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int SetParameters(this ComPtr thisVtbl, WICDdsParameters* pParameters) + public static unsafe int SetParameters(this ComPtr thisVtbl, DdsParameters* pParameters) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParameters); return ret; } /// To be documented. - public static int SetParameters(this ComPtr thisVtbl, ref WICDdsParameters pParameters) + public static int SetParameters(this ComPtr thisVtbl, ref DdsParameters pParameters) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICDdsParameters* pParametersPtr = &pParameters) + fixed (DdsParameters* pParametersPtr = &pParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pParametersPtr); } return ret; } /// To be documented. - public static unsafe int GetParameters(this ComPtr thisVtbl, WICDdsParameters* pParameters) + public static unsafe int GetParameters(this ComPtr thisVtbl, DdsParameters* pParameters) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParameters); return ret; } /// To be documented. - public static int GetParameters(this ComPtr thisVtbl, ref WICDdsParameters pParameters) + public static int GetParameters(this ComPtr thisVtbl, ref DdsParameters pParameters) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICDdsParameters* pParametersPtr = &pParameters) + fixed (DdsParameters* pParametersPtr = &pParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pParametersPtr); } return ret; } @@ -392,7 +392,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, Sp } /// To be documented. - public static int SetParameters(this ComPtr thisVtbl, Span pParameters) + public static int SetParameters(this ComPtr thisVtbl, Span pParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -400,7 +400,7 @@ public static int SetParameters(this ComPtr thisVtbl, SpanTo be documented. - public static int GetParameters(this ComPtr thisVtbl, Span pParameters) + public static int GetParameters(this ComPtr thisVtbl, Span pParameters) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs index 82394a8f17..ac33d50a42 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs @@ -133,94 +133,94 @@ public static int GetSizeInBlocks(this ComPtr thisVtbl, ref } /// To be documented. - public static unsafe int GetFormatInfo(this ComPtr thisVtbl, WICDdsFormatInfo* pFormatInfo) + public static unsafe int GetFormatInfo(this ComPtr thisVtbl, DdsFormatInfo* pFormatInfo) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfo); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfo); return ret; } /// To be documented. - public static int GetFormatInfo(this ComPtr thisVtbl, ref WICDdsFormatInfo pFormatInfo) + public static int GetFormatInfo(this ComPtr thisVtbl, ref DdsFormatInfo pFormatInfo) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICDdsFormatInfo* pFormatInfoPtr = &pFormatInfo) + fixed (DdsFormatInfo* pFormatInfoPtr = &pFormatInfo) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfoPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pFormatInfoPtr); } return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -276,7 +276,7 @@ public static int GetSizeInBlocks(this ComPtr thisVtbl, Span } /// To be documented. - public static int GetFormatInfo(this ComPtr thisVtbl, Span pFormatInfo) + public static int GetFormatInfo(this ComPtr thisVtbl, Span pFormatInfo) { var @this = thisVtbl.Handle; // SpanOverloader @@ -284,7 +284,7 @@ public static int GetFormatInfo(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -292,7 +292,7 @@ public static unsafe int CopyBlocks(this ComPtr thisVtbl, [F } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -300,7 +300,7 @@ public static unsafe int CopyBlocks(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -308,7 +308,7 @@ public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Sil } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs index c77a44492a..01dc7073ef 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPale } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -386,32 +386,32 @@ public static unsafe int GetThumbnail(this ComPtr thisVtbl, ref } /// To be documented. - public static unsafe int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, WICRawCapabilitiesInfo* pInfo) + public static unsafe int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, RawCapabilitiesInfo* pInfo) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfo); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfo); return ret; } /// To be documented. - public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, ref WICRawCapabilitiesInfo pInfo) + public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, ref RawCapabilitiesInfo pInfo) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRawCapabilitiesInfo* pInfoPtr = &pInfo) + fixed (RawCapabilitiesInfo* pInfoPtr = &pInfo) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfoPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pInfoPtr); } return ret; } /// To be documented. - public static int LoadParameterSet(this ComPtr thisVtbl, WICRawParameterSet ParameterSet) + public static int LoadParameterSet(this ComPtr thisVtbl, RawParameterSet ParameterSet) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ParameterSet); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[12])(@this, ParameterSet); return ret; } @@ -584,31 +584,31 @@ public static int GetWhitePointRGB(this ComPtr thisVtbl, ref uin } /// To be documented. - public static int SetNamedWhitePoint(this ComPtr thisVtbl, WICNamedWhitePoint WhitePoint) + public static int SetNamedWhitePoint(this ComPtr thisVtbl, NamedWhitePoint WhitePoint) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, WhitePoint); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, WhitePoint); return ret; } /// To be documented. - public static unsafe int GetNamedWhitePoint(this ComPtr thisVtbl, WICNamedWhitePoint* pWhitePoint) + public static unsafe int GetNamedWhitePoint(this ComPtr thisVtbl, NamedWhitePoint* pWhitePoint) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePoint); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePoint); return ret; } /// To be documented. - public static int GetNamedWhitePoint(this ComPtr thisVtbl, ref WICNamedWhitePoint pWhitePoint) + public static int GetNamedWhitePoint(this ComPtr thisVtbl, ref NamedWhitePoint pWhitePoint) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICNamedWhitePoint* pWhitePointPtr = &pWhitePoint) + fixed (NamedWhitePoint* pWhitePointPtr = &pWhitePoint) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePointPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[19])(@this, pWhitePointPtr); } return ret; } @@ -953,69 +953,69 @@ public static int SetDestinationColorContext(this ComPtr thisVtb } /// To be documented. - public static unsafe int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) + public static unsafe int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurve* pToneCurve) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurve); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurve); return ret; } /// To be documented. - public static int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve) + public static int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurve pToneCurve) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + fixed (RawToneCurve* pToneCurvePtr = &pToneCurve) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurvePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[36])(@this, cbToneCurveSize, pToneCurvePtr); } return ret; } /// To be documented. - public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); return ret; } /// To be documented. - public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSizePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSizePtr); } return ret; } /// To be documented. - public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + fixed (RawToneCurve* pToneCurvePtr = &pToneCurve) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSize); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSize); } return ret; } /// To be documented. - public static int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) + public static int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRawToneCurve* pToneCurvePtr = &pToneCurve) + fixed (RawToneCurve* pToneCurvePtr = &pToneCurve) { fixed (uint* pcbActualToneCurveBufferSizePtr = &pcbActualToneCurveBufferSize) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSizePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[37])(@this, cbToneCurveBufferSize, pToneCurvePtr, pcbActualToneCurveBufferSizePtr); } } return ret; @@ -1052,31 +1052,31 @@ public static int GetRotation(this ComPtr thisVtbl, ref double p } /// To be documented. - public static int SetRenderMode(this ComPtr thisVtbl, WICRawRenderMode RenderMode) + public static int SetRenderMode(this ComPtr thisVtbl, RawRenderMode RenderMode) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[40])(@this, RenderMode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[40])(@this, RenderMode); return ret; } /// To be documented. - public static unsafe int GetRenderMode(this ComPtr thisVtbl, WICRawRenderMode* pRenderMode) + public static unsafe int GetRenderMode(this ComPtr thisVtbl, RawRenderMode* pRenderMode) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderMode); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderMode); return ret; } /// To be documented. - public static int GetRenderMode(this ComPtr thisVtbl, ref WICRawRenderMode pRenderMode) + public static int GetRenderMode(this ComPtr thisVtbl, ref RawRenderMode pRenderMode) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRawRenderMode* pRenderModePtr = &pRenderMode) + fixed (RawRenderMode* pRenderModePtr = &pRenderMode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderModePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[41])(@this, pRenderModePtr); } return ret; } @@ -1200,7 +1200,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1208,7 +1208,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1216,7 +1216,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1224,7 +1224,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NE } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1280,7 +1280,7 @@ public static int GetThumbnail(this ComPtr thisVtbl, ref Co } /// To be documented. - public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, Span pInfo) + public static int QueryRawCapabilitiesInfo(this ComPtr thisVtbl, Span pInfo) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1360,7 +1360,7 @@ public static int GetWhitePointRGB(this ComPtr thisVtbl, SpanTo be documented. - public static int GetNamedWhitePoint(this ComPtr thisVtbl, Span pWhitePoint) + public static int GetNamedWhitePoint(this ComPtr thisVtbl, Span pWhitePoint) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1496,7 +1496,7 @@ public static int SetDestinationColorContext(this ComPtr thisVtb } /// To be documented. - public static int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) + public static int SetToneCurve(this ComPtr thisVtbl, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1504,7 +1504,7 @@ public static int SetToneCurve(this ComPtr thisVtbl, uint cbTone } /// To be documented. - public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1512,7 +1512,7 @@ public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint } /// To be documented. - public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) + public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1520,7 +1520,7 @@ public static unsafe int GetToneCurve(this ComPtr thisVtbl, uint } /// To be documented. - public static int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) + public static int GetToneCurve(this ComPtr thisVtbl, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1536,7 +1536,7 @@ public static int GetRotation(this ComPtr thisVtbl, Span } /// To be documented. - public static int GetRenderMode(this ComPtr thisVtbl, Span pRenderMode) + public static int GetRenderMode(this ComPtr thisVtbl, Span pRenderMode) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs index 4f05c12960..8d958aac53 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -555,7 +555,7 @@ public static unsafe int QueryInterface(this ComPtr thi } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs index d78ac603f1..86329e7ca9 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs @@ -223,113 +223,113 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWI } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -337,26 +337,26 @@ public static unsafe int Initialize(this ComPtr thisVtbl, I { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -364,14 +364,14 @@ public static unsafe int Initialize(this ComPtr thisVtbl, r { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -379,14 +379,14 @@ public static unsafe int Initialize(this ComPtr thisVtbl, r { fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -396,7 +396,7 @@ public static int Initialize(this ComPtr thisVtbl, ref IWIC { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } } @@ -609,7 +609,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [ } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [ } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -633,7 +633,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Si } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -641,7 +641,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Si } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -649,7 +649,7 @@ public static unsafe int Initialize(this ComPtr t } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Guid* dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -657,7 +657,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, I } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -665,7 +665,7 @@ public static unsafe int Initialize(this ComPtr thisVt } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Span dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -673,7 +673,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, I } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -681,7 +681,7 @@ public static int Initialize(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, Span dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -689,7 +689,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, I } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -697,7 +697,7 @@ public static int Initialize(this ComPtr thisVtbl, Com } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -705,7 +705,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, S } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -713,7 +713,7 @@ public static unsafe int Initialize(this ComPtr thisVt } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Guid* dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -721,7 +721,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, S } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, Span dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -729,7 +729,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, S } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -737,7 +737,7 @@ public static int Initialize(this ComPtr thisVtbl, ref } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pISource, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static int Initialize(this ComPtr thisVtbl, Span pISource, Span dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs index 388381a586..8dd123d10b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImageEncoderVtblExtensions.gen.cs @@ -85,82 +85,82 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParameters); return ret; } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncode, pImageParametersPtr); } return ret; } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParameters); } return ret; } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); } } return ret; } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParameters); } return ret; } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); } } return ret; } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; @@ -168,14 +168,14 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, ref { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); } } return ret; } /// To be documented. - public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; @@ -183,9 +183,9 @@ public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NE { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); } } } @@ -193,82 +193,82 @@ public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NE } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParameters); return ret; } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncode, pImageParametersPtr); } return ret; } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParameters); } return ret; } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImage, pFrameEncodePtr, pImageParametersPtr); } } return ret; } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParameters); } return ret; } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncode, pImageParametersPtr); } } return ret; } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; @@ -276,14 +276,14 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParameters); } } return ret; } /// To be documented. - public static int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapFrameEncode pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; @@ -291,9 +291,9 @@ public static int WriteFrameThumbnail(this ComPtr thisVtbl, re { fixed (IWICBitmapFrameEncode* pFrameEncodePtr = &pFrameEncode) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pImagePtr, pFrameEncodePtr, pImageParametersPtr); } } } @@ -301,82 +301,82 @@ public static int WriteFrameThumbnail(this ComPtr thisVtbl, re } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParameters); return ret; } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoder, pImageParametersPtr); } return ret; } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParameters); } return ret; } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImage, pEncoderPtr, pImageParametersPtr); } } return ret; } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParameters); } return ret; } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Direct2D.ID2D1Image* pImagePtr = &pImage) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoder, pImageParametersPtr); } } return ret; } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; int ret = default; @@ -384,14 +384,14 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, { fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParameters); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParameters); } } return ret; } /// To be documented. - public static int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) + public static int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ref IWICBitmapEncoder pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) { var @this = thisVtbl.Handle; int ret = default; @@ -399,9 +399,9 @@ public static int WriteThumbnail(this ComPtr thisVtbl, ref Sil { fixed (IWICBitmapEncoder* pEncoderPtr = &pEncoder) { - fixed (WICImageParameters* pImageParametersPtr = &pImageParameters) + fixed (ImageParameters* pImageParametersPtr = &pImageParameters) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParametersPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, pImagePtr, pEncoderPtr, pImageParametersPtr); } } } @@ -434,7 +434,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -442,7 +442,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -450,7 +450,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -458,7 +458,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -466,7 +466,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -474,7 +474,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, Silk } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -482,7 +482,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, Span } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -490,7 +490,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -498,7 +498,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, Span } /// To be documented. - public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteFrame(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -506,7 +506,7 @@ public static int WriteFrame(this ComPtr thisVtbl, ref Si } /// To be documented. - public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrame(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -514,7 +514,7 @@ public static unsafe int WriteFrame(this ComPtr thisVtbl, Span } /// To be documented. - public static int WriteFrame(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static int WriteFrame(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -522,7 +522,7 @@ public static int WriteFrame(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -530,7 +530,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -538,7 +538,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -546,7 +546,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -554,7 +554,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -562,7 +562,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -570,7 +570,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -578,7 +578,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapFrameEncode* pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -586,7 +586,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV } /// To be documented. - public static int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteFrameThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -594,7 +594,7 @@ public static int WriteFrameThumbnail(this ComPtr thisVtb } /// To be documented. - public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -602,7 +602,7 @@ public static unsafe int WriteFrameThumbnail(this ComPtr thisV } /// To be documented. - public static int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static int WriteFrameThumbnail(this ComPtr thisVtbl, Span pImage, Span pFrameEncode, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -610,7 +610,7 @@ public static int WriteFrameThumbnail(this ComPtr thisVtbl, Sp } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -618,7 +618,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -626,7 +626,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -634,7 +634,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -642,7 +642,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Silk.NET.Direct2D.ID2D1Image* pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -650,7 +650,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -658,7 +658,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -666,7 +666,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisV } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, IWICBitmapEncoder* pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -674,7 +674,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, } /// To be documented. - public static int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteThumbnail(this ComPtr thisVtbl, ref Silk.NET.Direct2D.ID2D1Image pImage, ComPtr pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in ImageParameters pImageParameters) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -682,7 +682,7 @@ public static int WriteThumbnail(this ComPtr thisVtbl, re } /// To be documented. - public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICImageParameters* pImageParameters) + public static unsafe int WriteThumbnail(this ComPtr thisVtbl, Span pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ImageParameters* pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader @@ -690,7 +690,7 @@ public static unsafe int WriteThumbnail(this ComPtr thisVtbl, } /// To be documented. - public static int WriteThumbnail(this ComPtr thisVtbl, Span pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) + public static int WriteThumbnail(this ComPtr thisVtbl, Span pImage, Span pEncoder, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pImageParameters) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs index b03c5db049..6b062fb334 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactory2VtblExtensions.gen.cs @@ -85,40 +85,40 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -126,26 +126,26 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzFilenamePtr = &wzFilename) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -153,14 +153,14 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -168,14 +168,14 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -185,7 +185,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } } @@ -193,46 +193,46 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -241,7 +241,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } SilkMarshal.Free((nint)wzFilenamePtr); @@ -249,40 +249,40 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -290,26 +290,26 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -317,14 +317,14 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -332,14 +332,14 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -349,7 +349,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr)@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } } @@ -357,40 +357,40 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -398,7 +398,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtr)@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; @@ -837,40 +837,40 @@ public static unsafe int CreateColorTransformer(this ComPtr } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pixelFormatPtr = &pixelFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; @@ -878,47 +878,47 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl, { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; @@ -926,7 +926,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtr { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); } } return ret; @@ -1145,40 +1145,40 @@ public static unsafe int CreateBitmapFromMemory(this ComPtr } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1186,26 +1186,26 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; fixed (void* hBitmapPtr = &hBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1213,14 +1213,14 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1228,14 +1228,14 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1245,7 +1245,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); } } } @@ -1707,7 +1707,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtb } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1715,7 +1715,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1723,7 +1723,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1731,7 +1731,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1739,7 +1739,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1747,7 +1747,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1755,7 +1755,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1763,7 +1763,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1771,7 +1771,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1779,7 +1779,7 @@ public static int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1787,7 +1787,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1795,7 +1795,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1803,7 +1803,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1811,7 +1811,7 @@ public static int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1819,7 +1819,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1827,7 +1827,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1835,7 +1835,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1843,7 +1843,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1851,7 +1851,7 @@ public static int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1859,7 +1859,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1867,7 +1867,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1875,7 +1875,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1883,7 +1883,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1891,7 +1891,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1899,7 +1899,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1907,7 +1907,7 @@ public static int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1915,7 +1915,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1923,7 +1923,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1931,7 +1931,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1939,7 +1939,7 @@ public static int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2208,7 +2208,7 @@ public static int CreateColorTransformer(this ComPtr t } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2216,7 +2216,7 @@ public static unsafe int CreateBitmap(this ComPtr this } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2224,7 +2224,7 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl, } /// To be documented. - public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2232,7 +2232,7 @@ public static int CreateBitmap(this ComPtr thisVtbl, u } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2240,7 +2240,7 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl, } /// To be documented. - public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2248,7 +2248,7 @@ public static int CreateBitmapFromSource(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2256,7 +2256,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2264,7 +2264,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtr } /// To be documented. - public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2272,7 +2272,7 @@ public static int CreateBitmapFromSource(this ComPtr t } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2432,7 +2432,7 @@ public static unsafe int CreateBitmapFromMemory(this ComPtr } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2440,7 +2440,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2448,7 +2448,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2456,7 +2456,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2464,7 +2464,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2472,7 +2472,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2480,7 +2480,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2488,7 +2488,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2496,7 +2496,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2504,7 +2504,7 @@ public static int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs index b9ce325973..15b7c38237 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICImagingFactoryVtblExtensions.gen.cs @@ -85,40 +85,40 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -126,26 +126,26 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilename, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (char* wzFilenamePtr = &wzFilename) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -153,14 +153,14 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -168,14 +168,14 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -185,7 +185,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } } @@ -193,46 +193,46 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoder); SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendor, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; var wzFilenamePtr = (byte*) SilkMarshal.StringToPtr(wzFilename, NativeStringEncoding.LPWStr); fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoder); } SilkMarshal.Free((nint)wzFilenamePtr); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -241,7 +241,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtr)@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, wzFilenamePtr, pguidVendorPtr, dwDesiredAccess, metadataOptions, ppIDecoderPtr); } } SilkMarshal.Free((nint)wzFilenamePtr); @@ -249,40 +249,40 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -290,26 +290,26 @@ public static unsafe int CreateDecoderFromStream(this ComPtr { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStream, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Silk.NET.Core.Win32Extras.IStream* pIStreamPtr = &pIStream) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -317,14 +317,14 @@ public static unsafe int CreateDecoderFromStream(this ComPtr { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendor, metadataOptions, ppIDecoderPtr); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -332,14 +332,14 @@ public static unsafe int CreateDecoderFromStream(this ComPtr { fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoder); } } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -349,7 +349,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr { fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, pIStreamPtr, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } } @@ -357,40 +357,40 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoder); return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapDecoder** ppIDecoderPtr = &ppIDecoder) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendor, metadataOptions, ppIDecoderPtr); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidVendorPtr = &pguidVendor) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoder); } return ret; } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; int ret = default; @@ -398,7 +398,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtr)@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, hFile, pguidVendorPtr, metadataOptions, ppIDecoderPtr); } } return ret; @@ -837,40 +837,40 @@ public static unsafe int CreateColorTransformer(this ComPtr } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormat, option, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pixelFormatPtr = &pixelFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; @@ -878,47 +878,47 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl, { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, uiWidth, uiHeight, pixelFormatPtr, option, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSource, option, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; @@ -926,7 +926,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtr { fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, pIBitmapSourcePtr, option, ppIBitmapPtr); } } return ret; @@ -1145,40 +1145,40 @@ public static unsafe int CreateBitmapFromMemory(this ComPtr } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmap); return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmap** ppIBitmapPtr = &ppIBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalette, options, ppIBitmapPtr); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; fixed (void* hPalettePtr = &hPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1186,26 +1186,26 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmap, hPalettePtr, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; fixed (void* hBitmapPtr = &hBitmap) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmap); } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1213,14 +1213,14 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalette, options, ppIBitmapPtr); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1228,14 +1228,14 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmap); } } return ret; } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; int ret = default; @@ -1245,7 +1245,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtr)@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[21])(@this, hBitmapPtr, hPalettePtr, options, ppIBitmapPtr); } } } @@ -1659,7 +1659,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtbl } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1667,7 +1667,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1675,7 +1675,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1683,7 +1683,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1691,7 +1691,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1699,7 +1699,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1707,7 +1707,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1715,7 +1715,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1723,7 +1723,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1731,7 +1731,7 @@ public static int CreateDecoderFromFilename(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1739,7 +1739,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1747,7 +1747,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1755,7 +1755,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1763,7 +1763,7 @@ public static int CreateDecoderFromFilename(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFilename(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string wzFilename, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, uint dwDesiredAccess, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1771,7 +1771,7 @@ public static unsafe int CreateDecoderFromFilename(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1779,7 +1779,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1787,7 +1787,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1795,7 +1795,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1803,7 +1803,7 @@ public static int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Silk.NET.Core.Win32Extras.IStream* pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1811,7 +1811,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ComPtr pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1819,7 +1819,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1827,7 +1827,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1835,7 +1835,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1843,7 +1843,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1851,7 +1851,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromStream(this ComPtr thisVtbl, ref Silk.NET.Core.Win32Extras.IStream pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1859,7 +1859,7 @@ public static int CreateDecoderFromStream(this ComPtr t } /// To be documented. - public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromStream(this ComPtr thisVtbl, Span pIStream, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1867,7 +1867,7 @@ public static unsafe int CreateDecoderFromStream(this ComPtr } /// To be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1875,7 +1875,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, IWICBitmapDecoder** ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1883,7 +1883,7 @@ public static unsafe int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, WICDecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, DecodeOptions metadataOptions, ref ComPtr ppIDecoder) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -1891,7 +1891,7 @@ public static int CreateDecoderFromFileHandle(this ComPtrTo be documented. - public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, WICDecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) + public static unsafe int CreateDecoderFromFileHandle(this ComPtr thisVtbl, nuint hFile, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, DecodeOptions metadataOptions, ref IWICBitmapDecoder* ppIDecoder) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2160,7 +2160,7 @@ public static int CreateColorTransformer(this ComPtr th } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Guid* pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2168,7 +2168,7 @@ public static unsafe int CreateBitmap(this ComPtr thisV } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2176,7 +2176,7 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl, } /// To be documented. - public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, ref Guid pixelFormat, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2184,7 +2184,7 @@ public static int CreateBitmap(this ComPtr thisVtbl, ui } /// To be documented. - public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmap(this ComPtr thisVtbl, uint uiWidth, uint uiHeight, Span pixelFormat, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2192,7 +2192,7 @@ public static unsafe int CreateBitmap(this ComPtr thisVtbl, } /// To be documented. - public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2200,7 +2200,7 @@ public static int CreateBitmapFromSource(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2208,7 +2208,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, BitmapCreateCacheOption option, IWICBitmap** ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2216,7 +2216,7 @@ public static unsafe int CreateBitmapFromSource(this ComPtr } /// To be documented. - public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, WICBitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, BitmapCreateCacheOption option, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2224,7 +2224,7 @@ public static int CreateBitmapFromSource(this ComPtr th } /// To be documented. - public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, WICBitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSource(this ComPtr thisVtbl, Span pIBitmapSource, BitmapCreateCacheOption option, ref IWICBitmap* ppIBitmap) { var @this = thisVtbl.Handle; // SpanOverloader @@ -2384,7 +2384,7 @@ public static unsafe int CreateBitmapFromMemory(this ComPtr } /// To be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2392,7 +2392,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2400,7 +2400,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, ref T0 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2408,7 +2408,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, void* hBitmap, Span hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2416,7 +2416,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2424,7 +2424,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2432,7 +2432,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, void* hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2440,7 +2440,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, BitmapAlphaChannelOption options, IWICBitmap** ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader @@ -2448,7 +2448,7 @@ public static unsafe int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, WICBitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public static int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, ref T0 hBitmap, ref T1 hPalette, BitmapAlphaChannelOption options, ref ComPtr ppIBitmap) where T0 : unmanaged where T1 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -2456,7 +2456,7 @@ public static int CreateBitmapFromHBITMAP(this ComPtrTo be documented. - public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, WICBitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged + public static unsafe int CreateBitmapFromHBITMAP(this ComPtr thisVtbl, Span hBitmap, Span hPalette, BitmapAlphaChannelOption options, ref IWICBitmap* ppIBitmap) where T0 : unmanaged where T1 : unmanaged { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs index 6f6a76407f..51d590084d 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICJpegFrameDecodeVtblExtensions.gen.cs @@ -106,11 +106,11 @@ public static int DoesSupportIndexing(this ComPtr thisVtbl, } /// To be documented. - public static int SetIndexing(this ComPtr thisVtbl, WICJpegIndexingOptions options, uint horizontalIntervalSize) + public static int SetIndexing(this ComPtr thisVtbl, JpegIndexingOptions options, uint horizontalIntervalSize) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, options, horizontalIntervalSize); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, options, horizontalIntervalSize); return ret; } @@ -187,43 +187,43 @@ public static int GetQuantizationTable(this ComPtr thisVtbl } /// To be documented. - public static unsafe int GetFrameHeader(this ComPtr thisVtbl, WICJpegFrameHeader* pFrameHeader) + public static unsafe int GetFrameHeader(this ComPtr thisVtbl, JpegFrameHeader* pFrameHeader) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeader); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeader); return ret; } /// To be documented. - public static int GetFrameHeader(this ComPtr thisVtbl, ref WICJpegFrameHeader pFrameHeader) + public static int GetFrameHeader(this ComPtr thisVtbl, ref JpegFrameHeader pFrameHeader) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICJpegFrameHeader* pFrameHeaderPtr = &pFrameHeader) + fixed (JpegFrameHeader* pFrameHeaderPtr = &pFrameHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeaderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[9])(@this, pFrameHeaderPtr); } return ret; } /// To be documented. - public static unsafe int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, WICJpegScanHeader* pScanHeader) + public static unsafe int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, JpegScanHeader* pScanHeader) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeader); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeader); return ret; } /// To be documented. - public static int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, ref WICJpegScanHeader pScanHeader) + public static int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, ref JpegScanHeader pScanHeader) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICJpegScanHeader* pScanHeaderPtr = &pScanHeader) + fixed (JpegScanHeader* pScanHeaderPtr = &pScanHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeaderPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[10])(@this, scanIndex, pScanHeaderPtr); } return ret; } @@ -432,7 +432,7 @@ public static int GetQuantizationTable(this ComPtr thisVtbl } /// To be documented. - public static int GetFrameHeader(this ComPtr thisVtbl, Span pFrameHeader) + public static int GetFrameHeader(this ComPtr thisVtbl, Span pFrameHeader) { var @this = thisVtbl.Handle; // SpanOverloader @@ -440,7 +440,7 @@ public static int GetFrameHeader(this ComPtr thisVtbl, Span } /// To be documented. - public static int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, Span pScanHeader) + public static int GetScanHeader(this ComPtr thisVtbl, uint scanIndex, Span pScanHeader) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs index b186974b3f..b415fe0c71 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataHandlerInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -764,7 +764,7 @@ public static unsafe int QueryInterface(this ComPtr thi } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs index e6805c9f68..947ee61151 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataReaderInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -739,40 +739,40 @@ public static int DoesRequireFixedSize(this ComPtr thisV } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCount, pcbActualPtr); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActual); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; @@ -780,66 +780,66 @@ public static unsafe int GetPatterns(this ComPtr thisVtb { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPattern, pcCountPtr, pcbActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActual); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCount, pcbActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActual); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); } } } @@ -847,19 +847,19 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActual); } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; @@ -867,14 +867,14 @@ public static unsafe int GetPatterns(this ComPtr thisVtb { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCount, pcbActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; @@ -882,14 +882,14 @@ public static unsafe int GetPatterns(this ComPtr thisVtb { fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActual); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; @@ -899,7 +899,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPattern, pcCountPtr, pcbActualPtr); } } } @@ -907,32 +907,32 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActual); } } return ret; } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCount, pcbActualPtr); } } } @@ -940,17 +940,17 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActual); } } } @@ -958,19 +958,19 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) + public static int GetPatterns(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataPattern* pPatternPtr = &pPattern) + fixed (MetadataPattern* pPatternPtr = &pPattern) { fixed (uint* pcCountPtr = &pcCount) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pPatternPtr, pcCountPtr, pcbActualPtr); } } } @@ -1133,7 +1133,7 @@ public static unsafe int QueryInterface(this ComPtr this } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1413,7 +1413,7 @@ public static int DoesRequireFixedSize(this ComPtr thisV } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1421,7 +1421,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1429,7 +1429,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1437,7 +1437,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1445,7 +1445,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1453,7 +1453,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1461,7 +1461,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1469,7 +1469,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1477,7 +1477,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1485,7 +1485,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1493,7 +1493,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1501,7 +1501,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1509,7 +1509,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1517,7 +1517,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + public static unsafe int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1525,7 +1525,7 @@ public static unsafe int GetPatterns(this ComPtr thisVtb } /// To be documented. - public static int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + public static int GetPatterns(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs index a294e2b194..f00988d28d 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICMetadataWriterInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -739,67 +739,67 @@ public static int DoesRequireFixedSize(this ComPtr thisV } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActual); return ret; } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeader, pcbActualPtr); } return ret; } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActual); } return ret; } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormat, cbSize, pHeaderPtr, pcbActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActual); } return ret; } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; @@ -807,39 +807,39 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeader, pcbActualPtr); } } return ret; } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActual); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActual); } } return ret; } /// To be documented. - public static int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) + public static int GetHeader(this ComPtr thisVtbl, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* guidContainerFormatPtr = &guidContainerFormat) { - fixed (WICMetadataHeader* pHeaderPtr = &pHeader) + fixed (MetadataHeader* pHeaderPtr = &pHeader) { fixed (uint* pcbActualPtr = &pcbActual) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActualPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[18])(@this, guidContainerFormatPtr, cbSize, pHeaderPtr, pcbActualPtr); } } } @@ -893,7 +893,7 @@ public static unsafe int QueryInterface(this ComPtr this } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1173,7 +1173,7 @@ public static int DoesRequireFixedSize(this ComPtr thisV } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1181,7 +1181,7 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1189,7 +1189,7 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1197,7 +1197,7 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1205,7 +1205,7 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, MetadataHeader* pHeader, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1213,7 +1213,7 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + public static unsafe int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1221,7 +1221,7 @@ public static unsafe int GetHeader(this ComPtr thisVtbl, } /// To be documented. - public static int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + public static int GetHeader(this ComPtr thisVtbl, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs index 2bd668e147..422586dcfb 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPaletteVtblExtensions.gen.cs @@ -85,11 +85,11 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static int InitializePredefined(this ComPtr thisVtbl, WICBitmapPaletteType ePaletteType, Silk.NET.Core.Bool32 fAddTransparentColor) + public static int InitializePredefined(this ComPtr thisVtbl, BitmapPaletteType ePaletteType, Silk.NET.Core.Bool32 fAddTransparentColor) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ePaletteType, fAddTransparentColor); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, ePaletteType, fAddTransparentColor); return ret; } @@ -157,22 +157,22 @@ public static int InitializeFromPalette(this ComPtr thisVtbl, ref I } /// To be documented. - public static unsafe int GetType(this ComPtr thisVtbl, WICBitmapPaletteType* pePaletteType) + public static unsafe int GetType(this ComPtr thisVtbl, BitmapPaletteType* pePaletteType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteType); return ret; } /// To be documented. - public static int GetType(this ComPtr thisVtbl, ref WICBitmapPaletteType pePaletteType) + public static int GetType(this ComPtr thisVtbl, ref BitmapPaletteType pePaletteType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPaletteType* pePaletteTypePtr = &pePaletteType) + fixed (BitmapPaletteType* pePaletteTypePtr = &pePaletteType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, pePaletteTypePtr); } return ret; } @@ -375,7 +375,7 @@ public static int InitializeFromPalette(this ComPtr thisVtbl, Span< } /// To be documented. - public static int GetType(this ComPtr thisVtbl, Span pePaletteType) + public static int GetType(this ComPtr thisVtbl, Span pePaletteType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs index 2294732f66..cf7f1abb04 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfo2VtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -639,22 +639,22 @@ public static int SupportsTransparency(this ComPtr thisVtb } /// To be documented. - public static unsafe int GetNumericRepresentation(this ComPtr thisVtbl, WICPixelFormatNumericRepresentation* pNumericRepresentation) + public static unsafe int GetNumericRepresentation(this ComPtr thisVtbl, PixelFormatNumericRepresentation* pNumericRepresentation) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentation); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentation); return ret; } /// To be documented. - public static int GetNumericRepresentation(this ComPtr thisVtbl, ref WICPixelFormatNumericRepresentation pNumericRepresentation) + public static int GetNumericRepresentation(this ComPtr thisVtbl, ref PixelFormatNumericRepresentation pNumericRepresentation) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICPixelFormatNumericRepresentation* pNumericRepresentationPtr = &pNumericRepresentation) + fixed (PixelFormatNumericRepresentation* pNumericRepresentationPtr = &pNumericRepresentation) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentationPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[17])(@this, pNumericRepresentationPtr); } return ret; } @@ -685,7 +685,7 @@ public static unsafe int QueryInterface(this ComPtr thisVt } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader @@ -917,7 +917,7 @@ public static int SupportsTransparency(this ComPtr thisVtb } /// To be documented. - public static int GetNumericRepresentation(this ComPtr thisVtbl, Span pNumericRepresentation) + public static int GetNumericRepresentation(this ComPtr thisVtbl, Span pNumericRepresentation) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs index 8b7e0e7550..5fc5f2a2fd 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPixelFormatInfoVtblExtensions.gen.cs @@ -85,22 +85,22 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int GetComponentType(this ComPtr thisVtbl, WICComponentType* pType) + public static unsafe int GetComponentType(this ComPtr thisVtbl, ComponentType* pType) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pType); return ret; } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, ref WICComponentType pType) + public static int GetComponentType(this ComPtr thisVtbl, ref ComponentType pType) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICComponentType* pTypePtr = &pType) + fixed (ComponentType* pTypePtr = &pType) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, pTypePtr); } return ret; } @@ -643,7 +643,7 @@ public static unsafe int QueryInterface(this ComPtr thisVtb } /// To be documented. - public static int GetComponentType(this ComPtr thisVtbl, Span pType) + public static int GetComponentType(this ComPtr thisVtbl, Span pType) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs index 4745cadcf8..523f104bab 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs @@ -85,69 +85,69 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int WritePixels(this ComPtr thisVtbl, uint lineCount, WICBitmapPlane* pPlanes, uint cPlanes) + public static unsafe int WritePixels(this ComPtr thisVtbl, uint lineCount, BitmapPlane* pPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanes, cPlanes); return ret; } /// To be documented. - public static int WritePixels(this ComPtr thisVtbl, uint lineCount, ref WICBitmapPlane pPlanes, uint cPlanes) + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, ref BitmapPlane pPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPlane* pPlanesPtr = &pPlanes) + fixed (BitmapPlane* pPlanesPtr = &pPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, lineCount, pPlanesPtr, cPlanes); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, WICRect* prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Rect* prcSource) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref WICRect prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Rect prcSource) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, WICRect* prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Rect* prcSource) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref WICRect prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Rect prcSource) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); } } return ret; @@ -179,7 +179,7 @@ public static unsafe int QueryInterface(this ComPtr } /// To be documented. - public static int WritePixels(this ComPtr thisVtbl, uint lineCount, Span pPlanes, uint cPlanes) + public static int WritePixels(this ComPtr thisVtbl, uint lineCount, Span pPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader @@ -187,7 +187,7 @@ public static int WritePixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, WICRect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Rect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -195,7 +195,7 @@ public static unsafe int WriteSource(this ComPtrTo be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span prcSource) { var @this = thisVtbl.Handle; // SpanOverloader @@ -203,7 +203,7 @@ public static unsafe int WriteSource(this ComPtr th } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref WICRect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Rect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -211,7 +211,7 @@ public static int WriteSource(this ComPtr this } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span prcSource) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs index aedf279566..c34bdf6853 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs @@ -85,67 +85,67 @@ public static uint Release(this ComPtr thisVtbl } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -153,39 +153,39 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatsPtr = &pguidDstFormats) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -193,19 +193,19 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* puiHeightPtr = &puiHeight) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -213,39 +213,39 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* puiHeightPtr = &puiHeight) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* puiHeightPtr = &puiHeight) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -253,7 +253,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -261,14 +261,14 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -278,7 +278,7 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -286,7 +286,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -294,9 +294,9 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -304,7 +304,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -312,11 +312,11 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidth, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -325,19 +325,19 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* puiWidthPtr = &puiWidth) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -345,39 +345,39 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* puiWidthPtr = &puiWidth) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; fixed (uint* puiWidthPtr = &puiWidth) { - fixed (WICBitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) + fixed (BitmapPlaneDescription* pPlaneDescriptionsPtr = &pPlaneDescriptions) { fixed (int* pfIsSupportedPtr = &pfIsSupported) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -385,7 +385,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -393,14 +393,14 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -410,7 +410,7 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -418,7 +418,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -426,9 +426,9 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -436,7 +436,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -444,11 +444,11 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeight, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -457,7 +457,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -465,14 +465,14 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupported); } } return ret; } /// To be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -482,7 +482,7 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -490,7 +490,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -498,9 +498,9 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -508,7 +508,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -516,11 +516,11 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormats, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -529,7 +529,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -539,7 +539,7 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupported); } } } @@ -547,7 +547,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -559,7 +559,7 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptions, cPlanes, pfIsSupportedPtr); } } } @@ -568,7 +568,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -578,9 +578,9 @@ public static unsafe int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupported); } } } @@ -589,7 +589,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref WICBitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) + public static int DoesSupportTransform(this ComPtr thisVtbl, ref uint puiWidth, ref uint puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidDstFormats, ref BitmapPlaneDescription pPlaneDescriptions, uint cPlanes, ref int pfIsSupported) { var @this = thisVtbl.Handle; int ret = default; @@ -599,11 +599,11 @@ public static int DoesSupportTransform(this ComPtr)@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, puiWidthPtr, puiHeightPtr, dstTransform, dstPlanarOptions, pguidDstFormatsPtr, pPlaneDescriptionsPtr, cPlanes, pfIsSupportedPtr); } } } @@ -613,48 +613,48 @@ public static int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICBitmapPlane pDstPlanes, uint cPlanes) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcSourcePtr = &prcSource) + fixed (Rect* prcSourcePtr = &prcSource) { - fixed (WICBitmapPlane* pDstPlanesPtr = &pDstPlanes) + fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } } return ret; @@ -686,7 +686,7 @@ public static unsafe int QueryInterface(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -694,7 +694,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -702,7 +702,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -710,7 +710,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -718,7 +718,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -726,7 +726,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -734,7 +734,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -742,7 +742,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -750,7 +750,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -758,7 +758,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -766,7 +766,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -774,7 +774,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -782,7 +782,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -790,7 +790,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -798,7 +798,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, uint* puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -806,7 +806,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -814,7 +814,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -822,7 +822,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -830,7 +830,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -838,7 +838,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -846,7 +846,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -854,7 +854,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -862,7 +862,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, uint* puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -870,7 +870,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -878,7 +878,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -886,7 +886,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -894,7 +894,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -902,7 +902,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -910,7 +910,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, WICBitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, BitmapPlaneDescription* pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -918,7 +918,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) + public static unsafe int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, int* pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -926,7 +926,7 @@ public static unsafe int DoesSupportTransform(this ComPtrTo be documented. - public static int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) + public static int DoesSupportTransform(this ComPtr thisVtbl, Span puiWidth, Span puiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidDstFormats, Span pPlaneDescriptions, uint cPlanes, Span pfIsSupported) { var @this = thisVtbl.Handle; // SpanOverloader @@ -934,7 +934,7 @@ public static int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader @@ -942,7 +942,7 @@ public static unsafe int CopyPixels(this ComPtr } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICBitmapPlane* pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader @@ -950,7 +950,7 @@ public static unsafe int CopyPixels(this ComPtr } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, WICBitmapTransformOptions dstTransform, WICPlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs index 7d17b62324..7fc74d5847 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs @@ -223,113 +223,113 @@ public static int CopyPalette(this ComPtr thisVtbl, r } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (WICRect* prcPtr = &prc) + fixed (Rect* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -337,26 +337,26 @@ public static unsafe int Initialize(this ComPtr thisV { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanes, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -364,14 +364,14 @@ public static unsafe int Initialize(this ComPtr thisV { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormat, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -379,14 +379,14 @@ public static unsafe int Initialize(this ComPtr thisV { fixed (Guid* dstFormatPtr = &dstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalette, alphaThresholdPercent, paletteTranslate); } } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; int ret = default; @@ -396,7 +396,7 @@ public static unsafe int Initialize(this ComPtr thisV { fixed (IWICPalette* pIPalettePtr = &pIPalette) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, ppPlanesPtr, cPlanes, dstFormatPtr, dither, pIPalettePtr, alphaThresholdPercent, paletteTranslate); } } } @@ -609,7 +609,7 @@ public static int CopyPalette(this ComPtr thisVtbl, S } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -633,7 +633,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -641,7 +641,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -649,7 +649,7 @@ public static unsafe int Initialize(this ComPtrTo be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -657,7 +657,7 @@ public static unsafe int Initialize(this ComPtr thisV } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -665,7 +665,7 @@ public static unsafe int Initialize(this ComPtr } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -673,7 +673,7 @@ public static unsafe int Initialize(this ComPtr thisV } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -681,7 +681,7 @@ public static int Initialize(this ComPtr th } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -689,7 +689,7 @@ public static unsafe int Initialize(this ComPtr thisV } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ref IWICPalette pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -697,7 +697,7 @@ public static int Initialize(this ComPtr thisVtb } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -705,7 +705,7 @@ public static unsafe int Initialize(this ComPtr } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Guid* dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -713,7 +713,7 @@ public static unsafe int Initialize(this ComPtr thisV } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span dstFormat, BitmapDitherType dither, IWICPalette* pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader @@ -721,7 +721,7 @@ public static unsafe int Initialize(this ComPtr thisV } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, WICBitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Guid dstFormat, BitmapDitherType dither, ComPtr pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -729,7 +729,7 @@ public static unsafe int Initialize(this ComPtr } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span dstFormat, WICBitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, WICBitmapPaletteType paletteTranslate) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span dstFormat, BitmapDitherType dither, Span pIPalette, double alphaThresholdPercent, BitmapPaletteType paletteTranslate) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs index 8a27d5132d..f828dfb6c3 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICProgressCallbackVtblExtensions.gen.cs @@ -85,11 +85,11 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static int Notify(this ComPtr thisVtbl, uint uFrameNum, WICProgressOperation operation, double dblProgress) + public static int Notify(this ComPtr thisVtbl, uint uFrameNum, ProgressOperation operation, double dblProgress) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, uFrameNum, operation, dblProgress); + ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, uFrameNum, operation, dblProgress); return ret; } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs index 244ece452d..35e01a7405 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecs.gen.cs @@ -66,46 +66,46 @@ public unsafe partial class WindowsCodecs : NativeAPI public const int WincodecErrBase = unchecked((int) 0x2000); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_ExposureCompensation")] - public const int WicrawChangeNotificationExposureCompensation = unchecked((int) 0x1); + public const int RawChangeNotificationExposureCompensation = unchecked((int) 0x1); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_NamedWhitePoint")] - public const int WicrawChangeNotificationNamedWhitePoint = unchecked((int) 0x2); + public const int RawChangeNotificationNamedWhitePoint = unchecked((int) 0x2); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_KelvinWhitePoint")] - public const int WicrawChangeNotificationKelvinWhitePoint = unchecked((int) 0x4); + public const int RawChangeNotificationKelvinWhitePoint = unchecked((int) 0x4); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_RGBWhitePoint")] - public const int WicrawChangeNotificationRgbwhitePoint = unchecked((int) 0x8); + public const int RawChangeNotificationRgbwhitePoint = unchecked((int) 0x8); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_Contrast")] - public const int WicrawChangeNotificationContrast = unchecked((int) 0x10); + public const int RawChangeNotificationContrast = unchecked((int) 0x10); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_Gamma")] - public const int WicrawChangeNotificationGamma = unchecked((int) 0x20); + public const int RawChangeNotificationGamma = unchecked((int) 0x20); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_Sharpness")] - public const int WicrawChangeNotificationSharpness = unchecked((int) 0x40); + public const int RawChangeNotificationSharpness = unchecked((int) 0x40); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_Saturation")] - public const int WicrawChangeNotificationSaturation = unchecked((int) 0x80); + public const int RawChangeNotificationSaturation = unchecked((int) 0x80); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_Tint")] - public const int WicrawChangeNotificationTint = unchecked((int) 0x100); + public const int RawChangeNotificationTint = unchecked((int) 0x100); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_NoiseReduction")] - public const int WicrawChangeNotificationNoiseReduction = unchecked((int) 0x200); + public const int RawChangeNotificationNoiseReduction = unchecked((int) 0x200); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_DestinationColorContext")] - public const int WicrawChangeNotificationDestinationColorContext = unchecked((int) 0x400); + public const int RawChangeNotificationDestinationColorContext = unchecked((int) 0x400); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_ToneCurve")] - public const int WicrawChangeNotificationToneCurve = unchecked((int) 0x800); + public const int RawChangeNotificationToneCurve = unchecked((int) 0x800); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_Rotation")] - public const int WicrawChangeNotificationRotation = unchecked((int) 0x1000); + public const int RawChangeNotificationRotation = unchecked((int) 0x1000); [NativeName("Type", "int")] [NativeName("Name", "WICRawChangeNotification_RenderMode")] - public const int WicrawChangeNotificationRenderMode = unchecked((int) 0x2000); + public const int RawChangeNotificationRenderMode = unchecked((int) 0x2000); /// To be documented. [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] @@ -210,42 +210,42 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, BitmapPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, BitmapPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, ref BitmapPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(IWICBitmapDecoderInfo* This, ref BitmapPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, BitmapPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, BitmapPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, ref BitmapPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref IWICBitmapDecoderInfo This, ref BitmapPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 6210, Column 17 in wincodec.h")] @@ -330,412 +330,412 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst); + public unsafe partial int ConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst); + public unsafe partial int ConvertBitmapSource(Guid* dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, IWICBitmapSource** ppIDst); + public unsafe partial int ConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, IWICBitmapSource** ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, ref IWICBitmapSource* ppIDst); + public unsafe partial int ConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, ref IWICBitmapSource* ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst); + public unsafe partial int ConvertBitmapSource(ref Guid dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst); + public unsafe partial int ConvertBitmapSource(ref Guid dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, IWICBitmapSource** ppIDst); + public unsafe partial int ConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, IWICBitmapSource** ppIDst); /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICConvertBitmapSource", Convention = CallingConvention.StdCall)] - public unsafe partial int WICConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, ref IWICBitmapSource* ppIDst); + public unsafe partial int ConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, ref IWICBitmapSource* ppIDst); /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap); + public unsafe partial int CreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap); /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap); + public unsafe partial int CreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap); /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap); + public unsafe partial int CreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap); /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap); + public unsafe partial int CreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap); /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSection", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap); + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap); /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap); + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap); /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap); + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap); /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap); + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap); /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICCreateBitmapFromSectionEx", Convention = CallingConvention.StdCall)] - public unsafe partial int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; + public unsafe partial int CreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged; /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapGuidToShortName(Guid* guid, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapGuidToShortName(Guid* guid, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapGuidToShortName(Guid* guid, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, ref char wzName, ref uint pcchActual); + public unsafe partial int MapGuidToShortName(Guid* guid, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapGuidToShortName(Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public unsafe partial int MapGuidToShortName(Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapGuidToShortName(ref Guid guid, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapGuidToShortName(ref Guid guid, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapGuidToShortName(ref Guid guid, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public partial int WICMapGuidToShortName(ref Guid guid, uint cchName, ref char wzName, ref uint pcchActual); + public partial int MapGuidToShortName(ref Guid guid, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapGuidToShortName(ref Guid guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapGuidToShortName(ref Guid guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapGuidToShortName", Convention = CallingConvention.StdCall)] - public partial int WICMapGuidToShortName(ref Guid guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public partial int MapGuidToShortName(ref Guid guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Guid* pguid); + public unsafe partial int MapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Guid* pguid); /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Guid pguid); + public unsafe partial int MapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, ref Guid pguid); /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, Guid* pguid); + public unsafe partial int MapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, Guid* pguid); /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] - public partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref Guid pguid); + public partial int MapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In)] in char wzName, ref Guid pguid); /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Guid* pguid); + public unsafe partial int MapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Guid* pguid); /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapShortNameToGuid", Convention = CallingConvention.StdCall)] - public partial int WICMapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref Guid pguid); + public partial int MapShortNameToGuid([Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref Guid pguid); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + public partial int MapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public partial int MapSchemaToName(ref Guid guidMetadataFormat, ref char pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, ref uint pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); + public partial int MapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, ref char wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); + public unsafe partial int MapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual); /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] [NativeApi(EntryPoint = "WICMapSchemaToName", Convention = CallingConvention.StdCall)] - public partial int WICMapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); + public partial int MapSchemaToName(ref Guid guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, ref uint pcchActual); /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, WICRawCapabilitiesInfo* pInfo); + public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, RawCapabilitiesInfo* pInfo); /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, ref WICRawCapabilitiesInfo pInfo); + public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, ref RawCapabilitiesInfo pInfo); /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, WICRawCapabilitiesInfo* pInfo); + public unsafe partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, RawCapabilitiesInfo* pInfo); /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, ref WICRawCapabilitiesInfo pInfo); + public partial int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, ref RawCapabilitiesInfo pInfo); /// To be documented. [NativeName("Src", "Line 8224, Column 17 in wincodec.h")] @@ -820,22 +820,22 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints); /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurvePoint aPoints); /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + public unsafe partial int IWICDevelopRawRemoteSetToneCurveProxy(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints); /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawRemoteSetToneCurveProxy(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + public partial int IWICDevelopRawRemoteSetToneCurveProxy(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurvePoint aPoints); /// To be documented. [NativeName("Src", "Line 8237, Column 17 in wincodec.h")] @@ -920,42 +920,42 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, uint* pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, uint* pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, ref uint pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(IWICDevelopRaw* This, ref uint pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, uint* pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, uint* pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, ref uint pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_Remote_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawRemoteGetToneCurveProxy(ref IWICDevelopRaw This, ref uint pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 8250, Column 17 in wincodec.h")] @@ -2560,306 +2560,306 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] - public unsafe partial uint WICInProcPointerUserSize(uint* arg0, uint arg1, byte** arg2); + public unsafe partial uint InProcPointerUserSize(uint* arg0, uint arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] - public unsafe partial uint WICInProcPointerUserSize(uint* arg0, uint arg1, ref byte* arg2); + public unsafe partial uint InProcPointerUserSize(uint* arg0, uint arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] - public unsafe partial uint WICInProcPointerUserSize(ref uint arg0, uint arg1, byte** arg2); + public unsafe partial uint InProcPointerUserSize(ref uint arg0, uint arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserSize", Convention = CallingConvention.StdCall)] - public unsafe partial uint WICInProcPointerUserSize(ref uint arg0, uint arg1, ref byte* arg2); + public unsafe partial uint InProcPointerUserSize(ref uint arg0, uint arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, byte* arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserMarshal(uint* arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, byte** arg2); + public unsafe partial string InProcPointerUserMarshalS(uint* arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, byte* arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserMarshal(uint* arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserMarshalS(uint* arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, ref byte arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserMarshal(uint* arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, byte** arg2); + public unsafe partial string InProcPointerUserMarshalS(uint* arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, ref byte arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserMarshal(uint* arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserMarshalS(uint* arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial string InProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, byte* arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserMarshal(ref uint arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, byte** arg2); + public unsafe partial string InProcPointerUserMarshalS(ref uint arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, byte* arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserMarshal(ref uint arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserMarshalS(ref uint arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, ref byte arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserMarshal(ref uint arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, byte** arg2); + public unsafe partial string InProcPointerUserMarshalS(ref uint arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, ref byte arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserMarshal(ref uint arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserMarshalS(ref uint arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial string InProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserMarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, byte* arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(uint* arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, byte** arg2); + public unsafe partial string InProcPointerUserUnmarshalS(uint* arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, byte* arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(uint* arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserUnmarshalS(uint* arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, ref byte arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(uint* arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, byte** arg2); + public unsafe partial string InProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, ref byte arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(uint* arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial string InProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, byte* arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(ref uint arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, byte** arg2); + public unsafe partial string InProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, byte* arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(ref uint arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, byte** arg2); + public unsafe partial string InProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); + public unsafe partial string InProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial byte* WICInProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial byte* InProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] [NativeApi(EntryPoint = "WICInProcPointer_UserUnmarshal", Convention = CallingConvention.StdCall)] - public unsafe partial string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); + public unsafe partial string InProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2); /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] - public unsafe partial void WICInProcPointerUserFree(uint* arg0, byte** arg1); + public unsafe partial void InProcPointerUserFree(uint* arg0, byte** arg1); /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] - public unsafe partial void WICInProcPointerUserFree(uint* arg0, ref byte* arg1); + public unsafe partial void InProcPointerUserFree(uint* arg0, ref byte* arg1); /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] - public unsafe partial void WICInProcPointerUserFree(ref uint arg0, byte** arg1); + public unsafe partial void InProcPointerUserFree(ref uint arg0, byte** arg1); /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] [NativeApi(EntryPoint = "WICInProcPointer_UserFree", Convention = CallingConvention.StdCall)] - public unsafe partial void WICInProcPointerUserFree(ref uint arg0, ref byte* arg1); + public unsafe partial void InProcPointerUserFree(ref uint arg0, ref byte* arg1); /// To be documented. [NativeName("Src", "Line 9019, Column 41 in wincodec.h")] @@ -2904,362 +2904,362 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(IWICBitmapDecoderInfo* This, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); + public partial int IWICBitmapDecoderInfoGetPatternsProxy(ref IWICBitmapDecoderInfo This, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, BitmapPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, BitmapPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, ref BitmapPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(IWICBitmapDecoderInfo* This, ref BitmapPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, BitmapPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, WICBitmapPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, BitmapPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, ref BitmapPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICBitmapDecoderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICBitmapDecoderInfoGetPatternsStub(ref IWICBitmapDecoderInfo This, ref BitmapPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, WICRawCapabilitiesInfo* pInfo); + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, RawCapabilitiesInfo* pInfo); /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, ref WICRawCapabilitiesInfo pInfo); + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(IWICDevelopRaw* This, ref RawCapabilitiesInfo pInfo); /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, WICRawCapabilitiesInfo* pInfo); + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, RawCapabilitiesInfo* pInfo); /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, ref WICRawCapabilitiesInfo pInfo); + public partial int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref IWICDevelopRaw This, ref RawCapabilitiesInfo pInfo); /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(IWICDevelopRaw* This, WICRawCapabilitiesInfo* pInfo); + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(IWICDevelopRaw* This, RawCapabilitiesInfo* pInfo); /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(IWICDevelopRaw* This, ref WICRawCapabilitiesInfo pInfo); + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(IWICDevelopRaw* This, ref RawCapabilitiesInfo pInfo); /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(ref IWICDevelopRaw This, WICRawCapabilitiesInfo* pInfo); + public unsafe partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(ref IWICDevelopRaw This, RawCapabilitiesInfo* pInfo); /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_QueryRawCapabilitiesInfo_Stub", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(ref IWICDevelopRaw This, ref WICRawCapabilitiesInfo pInfo); + public partial int IWICDevelopRawQueryRawCapabilitiesInfoStub(ref IWICDevelopRaw This, ref RawCapabilitiesInfo pInfo); /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawSetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve); + public unsafe partial int IWICDevelopRawSetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurve* pToneCurve); /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawSetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve); + public unsafe partial int IWICDevelopRawSetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurve pToneCurve); /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawSetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve); + public unsafe partial int IWICDevelopRawSetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurve* pToneCurve); /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawSetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve); + public partial int IWICDevelopRawSetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurve pToneCurve); /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawSetToneCurveStub(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + public unsafe partial int IWICDevelopRawSetToneCurveStub(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints); /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawSetToneCurveStub(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + public unsafe partial int IWICDevelopRawSetToneCurveStub(IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurvePoint aPoints); /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawSetToneCurveStub(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints); + public unsafe partial int IWICDevelopRawSetToneCurveStub(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints); /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_SetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawSetToneCurveStub(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints); + public partial int IWICDevelopRawSetToneCurveStub(ref IWICDevelopRaw This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurvePoint aPoints); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(IWICDevelopRaw* This, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize); + public unsafe partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize); + public partial int IWICDevelopRawGetToneCurveProxy(ref IWICDevelopRaw This, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, uint* pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, uint* pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, ref uint pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(IWICDevelopRaw* This, ref uint pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, uint* pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, uint* pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, uint* pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, ref uint pcPoints, WICRawToneCurvePoint** paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, ref uint pcPoints, RawToneCurvePoint** paPoints); /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] [NativeApi(EntryPoint = "IWICDevelopRaw_GetToneCurve_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints); + public unsafe partial int IWICDevelopRawGetToneCurveStub(ref IWICDevelopRaw This, ref uint pcPoints, ref RawToneCurvePoint* paPoints); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_Remote_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoRemoteGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 1683, Column 17 in wincodecsdk.h")] @@ -3344,42 +3344,42 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_Remote_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + public partial int IWICMetadataWriterInfoRemoteGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 1953, Column 17 in wincodecsdk.h")] @@ -3464,162 +3464,162 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); + public unsafe partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, Guid* pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICMatchMetadataContent", Convention = CallingConvention.StdCall)] - public partial int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); + public partial int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ref Silk.NET.Core.Win32Extras.IStream pIStream, ref Guid pguidMetadataFormat); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + public unsafe partial int SerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + public unsafe partial int SerializeMetadataContent(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + public unsafe partial int SerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + public unsafe partial int SerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + public unsafe partial int SerializeMetadataContent(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + public unsafe partial int SerializeMetadataContent(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public unsafe partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); + public unsafe partial int SerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream); /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICSerializeMetadataContent", Convention = CallingConvention.StdCall)] - public partial int WICSerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); + public partial int SerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize); + public unsafe partial int GetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ref ulong pcbSize); + public unsafe partial int GetMetadataContentSize(Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, ref ulong pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, ulong* pcbSize); + public unsafe partial int GetMetadataContentSize(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, ulong* pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, ref ulong pcbSize); + public unsafe partial int GetMetadataContentSize(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, ref ulong pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize); + public unsafe partial int GetMetadataContentSize(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, ref ulong pcbSize); + public unsafe partial int GetMetadataContentSize(ref Guid guidContainerFormat, IWICMetadataWriter* pIWriter, ref ulong pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public unsafe partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, ulong* pcbSize); + public unsafe partial int GetMetadataContentSize(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, ulong* pcbSize); /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] [NativeApi(EntryPoint = "WICGetMetadataContentSize", Convention = CallingConvention.StdCall)] - public partial int WICGetMetadataContentSize(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, ref ulong pcbSize); + public partial int GetMetadataContentSize(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, ref ulong pcbSize); /// To be documented. [NativeName("Src", "Line 2425, Column 39 in wincodecsdk.h")] @@ -3928,362 +3928,362 @@ public unsafe partial class WindowsCodecs : NativeAPI /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual); + public unsafe partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); + public partial int IWICMetadataReaderInfoGetPatternsProxy(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(IWICMetadataReaderInfo* This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns); /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataReaderInfo_GetPatterns_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns); + public unsafe partial int IWICMetadataReaderInfoGetPatternsStub(ref IWICMetadataReaderInfo This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual); + public unsafe partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual); /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Proxy", Convention = CallingConvention.StdCall)] - public partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual); + public partial int IWICMetadataWriterInfoGetHeaderProxy(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, Guid* guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(IWICMetadataWriterInfo* This, ref Guid guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, Guid* guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader); + public unsafe partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, MetadataHeader* pHeader); /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] [NativeApi(EntryPoint = "IWICMetadataWriterInfo_GetHeader_Stub", Convention = CallingConvention.StdCall)] - public partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader); + public partial int IWICMetadataWriterInfoGetHeaderStub(ref IWICMetadataWriterInfo This, ref Guid guidContainerFormat, ref MetadataHeader pHeader); /// To be documented. [NativeName("Src", "Line 4968, Column 43 in wincodec.h")] @@ -4311,7 +4311,7 @@ public unsafe int IWICBitmapCodecProgressNotificationRemoteRegisterProgressNotif /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, WICBitmapPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, BitmapPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, pcPatterns); @@ -4319,7 +4319,7 @@ public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr T /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, WICBitmapPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, BitmapPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, ref pcPatterns); @@ -4327,7 +4327,7 @@ public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr T /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, ref BitmapPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, pcPatterns); @@ -4335,7 +4335,7 @@ public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr T /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr This, ref BitmapPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoRemoteGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, ref pcPatterns); @@ -4343,119 +4343,119 @@ public unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(ComPtr T /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public unsafe int WICConvertBitmapSource(Guid* dstFormat, ComPtr pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public unsafe int ConvertBitmapSource(Guid* dstFormat, ComPtr pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICConvertBitmapSource(dstFormat, (IWICBitmapSource*) pISrc.Handle, (IWICBitmapSource**) ppIDst.GetAddressOf()); + return ConvertBitmapSource(dstFormat, (IWICBitmapSource*) pISrc.Handle, (IWICBitmapSource**) ppIDst.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public unsafe int WICConvertBitmapSource(Guid* dstFormat, ComPtr pISrc, ref IWICBitmapSource* ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int ConvertBitmapSource(Guid* dstFormat, ComPtr pISrc, ref IWICBitmapSource* ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICConvertBitmapSource(dstFormat, (IWICBitmapSource*) pISrc.Handle, ref ppIDst); + return ConvertBitmapSource(dstFormat, (IWICBitmapSource*) pISrc.Handle, ref ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public unsafe int WICConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int ConvertBitmapSource(Guid* dstFormat, ref IWICBitmapSource pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICConvertBitmapSource(dstFormat, ref pISrc, (IWICBitmapSource**) ppIDst.GetAddressOf()); + return ConvertBitmapSource(dstFormat, ref pISrc, (IWICBitmapSource**) ppIDst.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public unsafe int WICConvertBitmapSource(ref Guid dstFormat, ComPtr pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public unsafe int ConvertBitmapSource(ref Guid dstFormat, ComPtr pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICConvertBitmapSource(ref dstFormat, (IWICBitmapSource*) pISrc.Handle, (IWICBitmapSource**) ppIDst.GetAddressOf()); + return ConvertBitmapSource(ref dstFormat, (IWICBitmapSource*) pISrc.Handle, (IWICBitmapSource**) ppIDst.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public unsafe int WICConvertBitmapSource(ref Guid dstFormat, ComPtr pISrc, ref IWICBitmapSource* ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int ConvertBitmapSource(ref Guid dstFormat, ComPtr pISrc, ref IWICBitmapSource* ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICConvertBitmapSource(ref dstFormat, (IWICBitmapSource*) pISrc.Handle, ref ppIDst); + return ConvertBitmapSource(ref dstFormat, (IWICBitmapSource*) pISrc.Handle, ref ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public unsafe int WICConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int ConvertBitmapSource(ref Guid dstFormat, ref IWICBitmapSource pISrc, ref ComPtr ppIDst) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICConvertBitmapSource(ref dstFormat, ref pISrc, (IWICBitmapSource**) ppIDst.GetAddressOf()); + return ConvertBitmapSource(ref dstFormat, ref pISrc, (IWICBitmapSource**) ppIDst.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSection(width, height, pixelFormat, hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSection(width, height, pixelFormat, hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSection(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSection(width, height, pixelFormat, ref hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSection(width, height, pixelFormat, ref hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSection(width, height, ref pixelFormat, hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSection(width, height, ref pixelFormat, hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSection(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSection(width, height, ref pixelFormat, ref hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSection(width, height, ref pixelFormat, ref hSection, stride, offset, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSectionEx(width, height, pixelFormat, hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSectionEx(width, height, pixelFormat, hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSectionEx(uint width, uint height, Guid* pixelFormat, ref T0 hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSectionEx(width, height, ref pixelFormat, hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSectionEx(width, height, ref pixelFormat, hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public unsafe int WICCreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int CreateBitmapFromSectionEx(uint width, uint height, ref Guid pixelFormat, ref T0 hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref ComPtr ppIBitmap) where T0 : unmanaged where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICCreateBitmapFromSectionEx(width, height, ref pixelFormat, ref hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); + return CreateBitmapFromSectionEx(width, height, ref pixelFormat, ref hSection, stride, offset, desiredAccessLevel, (IWICBitmap**) ppIBitmap.GetAddressOf()); } /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr This, WICRawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr This, RawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, pInfo); @@ -4463,7 +4463,7 @@ public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr< /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr This, ref WICRawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr This, ref RawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, ref pInfo); @@ -4471,7 +4471,7 @@ public unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ComPtr< /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cPoints, aPoints); @@ -4479,7 +4479,7 @@ public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurvePoint aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cPoints, in aPoints); @@ -4487,7 +4487,7 @@ public unsafe int IWICDevelopRawRemoteSetToneCurveProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, uint* pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, uint* pcPoints, RawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, pcPoints, paPoints); @@ -4495,7 +4495,7 @@ public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, uint* pcPoints, ref RawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, pcPoints, ref paPoints); @@ -4503,7 +4503,7 @@ public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, ref uint pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, ref uint pcPoints, RawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, ref pcPoints, paPoints); @@ -4511,7 +4511,7 @@ public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, r /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawRemoteGetToneCurveProxy(ComPtr This, ref uint pcPoints, ref RawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawRemoteGetToneCurveProxy((IWICDevelopRaw*) This.Handle, ref pcPoints, ref paPoints); @@ -4865,11 +4865,11 @@ public unsafe void BSTRUserFree(ref uint arg0, string[] arg1Sa) /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] - public unsafe uint WICInProcPointerUserSize(uint* arg0, uint arg1, string[] arg2Sa) + public unsafe uint InProcPointerUserSize(uint* arg0, uint arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserSize(arg0, arg1, arg2); + var ret = InProcPointerUserSize(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4877,11 +4877,11 @@ public unsafe uint WICInProcPointerUserSize(uint* arg0, uint arg1, string[] arg2 /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] - public unsafe uint WICInProcPointerUserSize(ref uint arg0, uint arg1, string[] arg2Sa) + public unsafe uint InProcPointerUserSize(ref uint arg0, uint arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserSize(ref arg0, arg1, arg2); + var ret = InProcPointerUserSize(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4889,11 +4889,11 @@ public unsafe uint WICInProcPointerUserSize(ref uint arg0, uint arg1, string[] a /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserMarshal(uint* arg0, byte* arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserMarshal(uint* arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshal(arg0, arg1, arg2); + var ret = InProcPointerUserMarshal(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4902,11 +4902,11 @@ public unsafe uint WICInProcPointerUserSize(ref uint arg0, uint arg1, string[] a /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + public unsafe string InProcPointerUserMarshalS(uint* arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshalS(arg0, arg1, arg2); + var ret = InProcPointerUserMarshalS(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4914,11 +4914,11 @@ public unsafe string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, string /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserMarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserMarshal(uint* arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshal(arg0, ref arg1, arg2); + var ret = InProcPointerUserMarshal(arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4927,11 +4927,11 @@ public unsafe string WICInProcPointerUserMarshalS(uint* arg0, byte* arg1, string /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + public unsafe string InProcPointerUserMarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshalS(arg0, ref arg1, arg2); + var ret = InProcPointerUserMarshalS(arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4939,11 +4939,11 @@ public unsafe string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, str /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserMarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshal(arg0, arg1, arg2); + var ret = InProcPointerUserMarshal(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4952,11 +4952,11 @@ public unsafe string WICInProcPointerUserMarshalS(uint* arg0, ref byte arg1, str /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe string InProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshalS(arg0, arg1, arg2); + var ret = InProcPointerUserMarshalS(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4964,11 +4964,11 @@ public unsafe string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Sil /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserMarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserMarshal(ref uint arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshal(ref arg0, arg1, arg2); + var ret = InProcPointerUserMarshal(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4977,11 +4977,11 @@ public unsafe string WICInProcPointerUserMarshalS(uint* arg0, [UnmanagedType(Sil /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + public unsafe string InProcPointerUserMarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshalS(ref arg0, arg1, arg2); + var ret = InProcPointerUserMarshalS(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -4989,11 +4989,11 @@ public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, str /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserMarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserMarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshal(ref arg0, ref arg1, arg2); + var ret = InProcPointerUserMarshal(ref arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5002,11 +5002,11 @@ public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, byte* arg1, str /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + public unsafe string InProcPointerUserMarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshalS(ref arg0, ref arg1, arg2); + var ret = InProcPointerUserMarshalS(ref arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5014,11 +5014,11 @@ public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserMarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshal(ref arg0, arg1, arg2); + var ret = InProcPointerUserMarshal(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5027,11 +5027,11 @@ public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, ref byte arg1, /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe string InProcPointerUserMarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserMarshalS(ref arg0, arg1, arg2); + var ret = InProcPointerUserMarshalS(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5039,11 +5039,11 @@ public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType( /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserUnmarshal(uint* arg0, byte* arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserUnmarshal(uint* arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshal(arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshal(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5052,11 +5052,11 @@ public unsafe string WICInProcPointerUserMarshalS(ref uint arg0, [UnmanagedType( /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, string[] arg2Sa) + public unsafe string InProcPointerUserUnmarshalS(uint* arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshalS(arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshalS(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5064,11 +5064,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, stri /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserUnmarshal(uint* arg0, ref byte arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserUnmarshal(uint* arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshal(arg0, ref arg1, arg2); + var ret = InProcPointerUserUnmarshal(arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5077,11 +5077,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, byte* arg1, stri /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) + public unsafe string InProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshalS(arg0, ref arg1, arg2); + var ret = InProcPointerUserUnmarshalS(arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5089,11 +5089,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, s /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserUnmarshal(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshal(arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshal(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5102,11 +5102,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, ref byte arg1, s /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe string InProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshalS(arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshalS(arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5114,11 +5114,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(S /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserUnmarshal(ref uint arg0, byte* arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserUnmarshal(ref uint arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshal(ref arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshal(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5127,11 +5127,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(uint* arg0, [UnmanagedType(S /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) + public unsafe string InProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshalS(ref arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshalS(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5139,11 +5139,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, s /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserUnmarshal(ref uint arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshal(ref arg0, ref arg1, arg2); + var ret = InProcPointerUserUnmarshal(ref arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5152,11 +5152,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, byte* arg1, s /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) + public unsafe string InProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshalS(ref arg0, ref arg1, arg2); + var ret = InProcPointerUserUnmarshalS(ref arg0, ref arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5164,11 +5164,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1 /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public unsafe byte* WICInProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe byte* InProcPointerUserUnmarshal(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshal(ref arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshal(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5177,11 +5177,11 @@ public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, ref byte arg1 /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] [return: UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] - public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) + public unsafe string InProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, string[] arg2Sa) { // StringArrayOverloader var arg2 = (byte**) SilkMarshal.StringArrayToPtr(arg2Sa); - var ret = WICInProcPointerUserUnmarshalS(ref arg0, arg1, arg2); + var ret = InProcPointerUserUnmarshalS(ref arg0, arg1, arg2); SilkMarshal.CopyPtrToStringArray((nint) arg2, arg2Sa); SilkMarshal.Free((nint) arg2); return ret; @@ -5189,22 +5189,22 @@ public unsafe string WICInProcPointerUserUnmarshalS(ref uint arg0, [UnmanagedTyp /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] - public unsafe void WICInProcPointerUserFree(uint* arg0, string[] arg1Sa) + public unsafe void InProcPointerUserFree(uint* arg0, string[] arg1Sa) { // StringArrayOverloader var arg1 = (byte**) SilkMarshal.StringArrayToPtr(arg1Sa); - WICInProcPointerUserFree(arg0, arg1); + InProcPointerUserFree(arg0, arg1); SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); SilkMarshal.Free((nint) arg1); } /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] - public unsafe void WICInProcPointerUserFree(ref uint arg0, string[] arg1Sa) + public unsafe void InProcPointerUserFree(ref uint arg0, string[] arg1Sa) { // StringArrayOverloader var arg1 = (byte**) SilkMarshal.StringArrayToPtr(arg1Sa); - WICInProcPointerUserFree(ref arg0, arg1); + InProcPointerUserFree(ref arg0, arg1); SilkMarshal.CopyPtrToStringArray((nint) arg1, arg1Sa); SilkMarshal.Free((nint) arg1); } @@ -5251,7 +5251,7 @@ public unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNotificatio /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); @@ -5259,7 +5259,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual); @@ -5267,7 +5267,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, ref pcPatterns, pcbPatternsActual); @@ -5275,7 +5275,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, WICBitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, BitmapPattern* pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, pPatterns, ref pcPatterns, ref pcbPatternsActual); @@ -5283,7 +5283,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, pcPatterns, pcbPatternsActual); @@ -5291,7 +5291,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref BitmapPattern pPatterns, uint* pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, pcPatterns, ref pcbPatternsActual); @@ -5299,7 +5299,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, uint* pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, ref pcPatterns, pcbPatternsActual); @@ -5307,7 +5307,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref WICBitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, uint cbSizePatterns, ref BitmapPattern pPatterns, ref uint pcPatterns, ref uint pcbPatternsActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsProxy((IWICBitmapDecoderInfo*) This.Handle, cbSizePatterns, ref pPatterns, ref pcPatterns, ref pcbPatternsActual); @@ -5315,7 +5315,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsProxy(ComPtr This, u /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, WICBitmapPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, BitmapPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, pcPatterns); @@ -5323,7 +5323,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, WI /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, WICBitmapPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, BitmapPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ppPatterns, ref pcPatterns); @@ -5331,7 +5331,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, WI /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, ref BitmapPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, pcPatterns); @@ -5339,7 +5339,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, re /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, ref WICBitmapPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, ref BitmapPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICBitmapDecoderInfoGetPatternsStub((IWICBitmapDecoderInfo*) This.Handle, ref ppPatterns, ref pcPatterns); @@ -5347,7 +5347,7 @@ public unsafe int IWICBitmapDecoderInfoGetPatternsStub(ComPtr This, re /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr This, WICRawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr This, RawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, pInfo); @@ -5355,7 +5355,7 @@ public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr T /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr This, ref WICRawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr This, ref RawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawQueryRawCapabilitiesInfoProxy((IWICDevelopRaw*) This.Handle, ref pInfo); @@ -5363,7 +5363,7 @@ public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(ComPtr T /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr This, WICRawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr This, RawCapabilitiesInfo* pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawQueryRawCapabilitiesInfoStub((IWICDevelopRaw*) This.Handle, pInfo); @@ -5371,7 +5371,7 @@ public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr Th /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr This, ref WICRawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr This, ref RawCapabilitiesInfo pInfo) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawQueryRawCapabilitiesInfoStub((IWICDevelopRaw*) This.Handle, ref pInfo); @@ -5379,7 +5379,7 @@ public unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(ComPtr Th /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurve* pToneCurve) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveSize, pToneCurve); @@ -5387,7 +5387,7 @@ public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cb /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurve pToneCurve) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurve pToneCurve) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawSetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveSize, in pToneCurve); @@ -5395,7 +5395,7 @@ public unsafe int IWICDevelopRawSetToneCurveProxy(ComPtr This, uint cb /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawSetToneCurveStub((IWICDevelopRaw*) This.Handle, cPoints, aPoints); @@ -5403,7 +5403,7 @@ public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPo /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in WICRawToneCurvePoint aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in RawToneCurvePoint aPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawSetToneCurveStub((IWICDevelopRaw*) This.Handle, cPoints, in aPoints); @@ -5411,7 +5411,7 @@ public unsafe int IWICDevelopRawSetToneCurveStub(ComPtr This, uint cPo /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); @@ -5419,7 +5419,7 @@ public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cb /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, ref uint pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize); @@ -5427,7 +5427,7 @@ public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cb /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, uint* pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, ref pToneCurve, pcbActualToneCurveBufferSize); @@ -5435,7 +5435,7 @@ public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cb /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, ref WICRawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cbToneCurveBufferSize, ref RawToneCurve pToneCurve, ref uint pcbActualToneCurveBufferSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveProxy((IWICDevelopRaw*) This.Handle, cbToneCurveBufferSize, ref pToneCurve, ref pcbActualToneCurveBufferSize); @@ -5443,7 +5443,7 @@ public unsafe int IWICDevelopRawGetToneCurveProxy(ComPtr This, uint cb /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pcPoints, RawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, pcPoints, paPoints); @@ -5451,7 +5451,7 @@ public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pc /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pcPoints, ref RawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, pcPoints, ref paPoints); @@ -5459,7 +5459,7 @@ public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, uint* pc /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint pcPoints, WICRawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint pcPoints, RawToneCurvePoint** paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, ref pcPoints, paPoints); @@ -5467,7 +5467,7 @@ public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint pcPoints, ref WICRawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint pcPoints, ref RawToneCurvePoint* paPoints) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICDevelopRawGetToneCurveStub((IWICDevelopRaw*) This.Handle, ref pcPoints, ref paPoints); @@ -5475,7 +5475,7 @@ public unsafe int IWICDevelopRawGetToneCurveStub(ComPtr This, ref uint /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, pcPatterns); @@ -5483,7 +5483,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, ref pcPatterns); @@ -5491,7 +5491,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, pcPatterns); @@ -5499,7 +5499,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, ref pcPatterns); @@ -5507,7 +5507,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, pcPatterns); @@ -5515,7 +5515,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, ref pcPatterns); @@ -5523,7 +5523,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, pcPatterns); @@ -5531,7 +5531,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoRemoteGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, ref pcPatterns); @@ -5539,7 +5539,7 @@ public unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(ComPtr /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, MetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, pHeader); @@ -5547,7 +5547,7 @@ public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr Th /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, ref MetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, ref pHeader); @@ -5555,7 +5555,7 @@ public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr Th /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, MetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, pHeader); @@ -5563,7 +5563,7 @@ public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr Th /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, ref MetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoRemoteGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, ref pHeader); @@ -5571,151 +5571,151 @@ public unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(ComPtr Th /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + return MatchMetadataContent(guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + return MatchMetadataContent(guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + return MatchMetadataContent(guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + return MatchMetadataContent(guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(ref guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + return MatchMetadataContent(ref guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(ref guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + return MatchMetadataContent(ref guidContainerFormat, pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, Guid* pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(ref guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); + return MatchMetadataContent(ref guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public unsafe int WICMatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int MatchMetadataContent(ref Guid guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Guid pguidVendor, ComPtr pIStream, ref Guid pguidMetadataFormat) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICMatchMetadataContent(ref guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); + return MatchMetadataContent(ref guidContainerFormat, in pguidVendor, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle, ref pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public unsafe int WICSerializeMetadataContent(Guid* guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public unsafe int SerializeMetadataContent(Guid* guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICSerializeMetadataContent(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + return SerializeMetadataContent(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public unsafe int WICSerializeMetadataContent(Guid* guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int SerializeMetadataContent(Guid* guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICSerializeMetadataContent(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, ref pIStream); + return SerializeMetadataContent(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, ref pIStream); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public unsafe int WICSerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int SerializeMetadataContent(Guid* guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICSerializeMetadataContent(guidContainerFormat, ref pIWriter, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + return SerializeMetadataContent(guidContainerFormat, ref pIWriter, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public unsafe int WICSerializeMetadataContent(ref Guid guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl + public unsafe int SerializeMetadataContent(ref Guid guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl where TI1 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICSerializeMetadataContent(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + return SerializeMetadataContent(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public unsafe int WICSerializeMetadataContent(ref Guid guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int SerializeMetadataContent(ref Guid guidContainerFormat, ComPtr pIWriter, uint dwPersistOptions, ref Silk.NET.Core.Win32Extras.IStream pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICSerializeMetadataContent(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, ref pIStream); + return SerializeMetadataContent(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, dwPersistOptions, ref pIStream); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public unsafe int WICSerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int SerializeMetadataContent(ref Guid guidContainerFormat, ref IWICMetadataWriter pIWriter, uint dwPersistOptions, ComPtr pIStream) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICSerializeMetadataContent(ref guidContainerFormat, ref pIWriter, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); + return SerializeMetadataContent(ref guidContainerFormat, ref pIWriter, dwPersistOptions, (Silk.NET.Core.Win32Extras.IStream*) pIStream.Handle); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public unsafe int WICGetMetadataContentSize(Guid* guidContainerFormat, ComPtr pIWriter, ulong* pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int GetMetadataContentSize(Guid* guidContainerFormat, ComPtr pIWriter, ulong* pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICGetMetadataContentSize(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, pcbSize); + return GetMetadataContentSize(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, pcbSize); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public unsafe int WICGetMetadataContentSize(Guid* guidContainerFormat, ComPtr pIWriter, ref ulong pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int GetMetadataContentSize(Guid* guidContainerFormat, ComPtr pIWriter, ref ulong pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICGetMetadataContentSize(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, ref pcbSize); + return GetMetadataContentSize(guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, ref pcbSize); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public unsafe int WICGetMetadataContentSize(ref Guid guidContainerFormat, ComPtr pIWriter, ulong* pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int GetMetadataContentSize(ref Guid guidContainerFormat, ComPtr pIWriter, ulong* pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICGetMetadataContentSize(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, pcbSize); + return GetMetadataContentSize(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, pcbSize); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public unsafe int WICGetMetadataContentSize(ref Guid guidContainerFormat, ComPtr pIWriter, ref ulong pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int GetMetadataContentSize(ref Guid guidContainerFormat, ComPtr pIWriter, ref ulong pcbSize) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader - return WICGetMetadataContentSize(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, ref pcbSize); + return GetMetadataContentSize(ref guidContainerFormat, (IWICMetadataWriter*) pIWriter.Handle, ref pcbSize); } /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); @@ -5723,7 +5723,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual); @@ -5731,7 +5731,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, ref pcCount, pcbActual); @@ -5739,7 +5739,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, pPattern, ref pcCount, ref pcbActual); @@ -5747,7 +5747,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, pcCount, pcbActual); @@ -5755,7 +5755,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, pcCount, ref pcbActual); @@ -5763,7 +5763,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, ref pcCount, pcbActual); @@ -5771,7 +5771,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, cbSize, ref pPattern, ref pcCount, ref pcbActual); @@ -5779,7 +5779,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); @@ -5787,7 +5787,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual); @@ -5795,7 +5795,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, ref pcCount, pcbActual); @@ -5803,7 +5803,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, MetadataPattern* pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, pPattern, ref pcCount, ref pcbActual); @@ -5811,7 +5811,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, pcCount, pcbActual); @@ -5819,7 +5819,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, uint* pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, pcCount, ref pcbActual); @@ -5827,7 +5827,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, ref pcCount, pcbActual); @@ -5835,7 +5835,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref MetadataPattern pPattern, ref uint pcCount, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsProxy((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pPattern, ref pcCount, ref pcbActual); @@ -5843,7 +5843,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsProxy(ComPtr This, /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, pcPatterns); @@ -5851,7 +5851,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, G /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ppPatterns, ref pcPatterns); @@ -5859,7 +5859,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, G /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, pcPatterns); @@ -5867,7 +5867,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, G /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, guidContainerFormat, ref ppPatterns, ref pcPatterns); @@ -5875,7 +5875,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, G /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, pcPatterns); @@ -5883,7 +5883,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, r /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, WICMetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, MetadataPattern** ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ppPatterns, ref pcPatterns); @@ -5891,7 +5891,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, r /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, pcPatterns); @@ -5899,7 +5899,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, r /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, ref Guid guidContainerFormat, ref MetadataPattern* ppPatterns, ref uint pcPatterns) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataReaderInfoGetPatternsStub((IWICMetadataReaderInfo*) This.Handle, ref guidContainerFormat, ref ppPatterns, ref pcPatterns); @@ -5907,7 +5907,7 @@ public unsafe int IWICMetadataReaderInfoGetPatternsStub(ComPtr This, r /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, pHeader, pcbActual); @@ -5915,7 +5915,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Gu /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, pHeader, ref pcbActual); @@ -5923,7 +5923,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Gu /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, ref pHeader, pcbActual); @@ -5931,7 +5931,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Gu /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Guid* guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, cbSize, ref pHeader, ref pcbActual); @@ -5939,7 +5939,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, Gu /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, pHeader, pcbActual); @@ -5947,7 +5947,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, re /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, MetadataHeader* pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, pHeader, ref pcbActual); @@ -5955,7 +5955,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, re /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, uint* pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pHeader, pcbActual); @@ -5963,7 +5963,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, re /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref WICMetadataHeader pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, ref Guid guidContainerFormat, uint cbSize, ref MetadataHeader pHeader, ref uint pcbActual) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderProxy((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, cbSize, ref pHeader, ref pcbActual); @@ -5971,7 +5971,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderProxy(ComPtr This, re /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Guid* guidContainerFormat, MetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, pHeader); @@ -5979,7 +5979,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Gui /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Guid* guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Guid* guidContainerFormat, ref MetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, guidContainerFormat, ref pHeader); @@ -5987,7 +5987,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, Gui /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref Guid guidContainerFormat, WICMetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref Guid guidContainerFormat, MetadataHeader* pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, pHeader); @@ -5995,7 +5995,7 @@ public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref Guid guidContainerFormat, ref WICMetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl + public unsafe int IWICMetadataWriterInfoGetHeaderStub(ComPtr This, ref Guid guidContainerFormat, ref MetadataHeader pHeader) where TI0 : unmanaged, IComVtbl, IComVtbl { // ComPtrOverloader return IWICMetadataWriterInfoGetHeaderStub((IWICMetadataWriterInfo*) This.Handle, ref guidContainerFormat, ref pHeader); diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs index 460bf765ab..5a8ef2508c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/WindowsCodecsOverloads.gen.cs @@ -162,7 +162,7 @@ public static unsafe void IWICBitmapCodecProgressNotificationRemoteRegisterProgr /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, BitmapPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(This, ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -170,7 +170,7 @@ public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this Window /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, ref BitmapPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(This, ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -178,7 +178,7 @@ public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this Window /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, BitmapPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ppPatterns, pcPatterns); @@ -186,7 +186,7 @@ public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this Window /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, BitmapPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -194,7 +194,7 @@ public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this Window /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, ref BitmapPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref ppPatterns, pcPatterns); @@ -202,7 +202,7 @@ public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this Window /// To be documented. [NativeName("Src", "Line 6204, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, ref BitmapPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -330,519 +330,519 @@ public static unsafe void IWICBitmapDecoderInfoRemoteGetPatternsStub(this Window /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Guid* dstFormat, Span pISrc, IWICBitmapSource** ppIDst) + public static unsafe int ConvertBitmapSource(this WindowsCodecs thisApi, Guid* dstFormat, Span pISrc, IWICBitmapSource** ppIDst) { // SpanOverloader - return thisApi.WICConvertBitmapSource(dstFormat, ref pISrc.GetPinnableReference(), ppIDst); + return thisApi.ConvertBitmapSource(dstFormat, ref pISrc.GetPinnableReference(), ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Guid* dstFormat, Span pISrc, ref IWICBitmapSource* ppIDst) + public static unsafe int ConvertBitmapSource(this WindowsCodecs thisApi, Guid* dstFormat, Span pISrc, ref IWICBitmapSource* ppIDst) { // SpanOverloader - return thisApi.WICConvertBitmapSource(dstFormat, ref pISrc.GetPinnableReference(), ref ppIDst); + return thisApi.ConvertBitmapSource(dstFormat, ref pISrc.GetPinnableReference(), ref ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst) + public static unsafe int ConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, IWICBitmapSource* pISrc, IWICBitmapSource** ppIDst) { // SpanOverloader - return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), pISrc, ppIDst); + return thisApi.ConvertBitmapSource(ref dstFormat.GetPinnableReference(), pISrc, ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst) + public static unsafe int ConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, IWICBitmapSource* pISrc, ref IWICBitmapSource* ppIDst) { // SpanOverloader - return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), pISrc, ref ppIDst); + return thisApi.ConvertBitmapSource(ref dstFormat.GetPinnableReference(), pISrc, ref ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, Span pISrc, IWICBitmapSource** ppIDst) + public static unsafe int ConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, Span pISrc, IWICBitmapSource** ppIDst) { // SpanOverloader - return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), ref pISrc.GetPinnableReference(), ppIDst); + return thisApi.ConvertBitmapSource(ref dstFormat.GetPinnableReference(), ref pISrc.GetPinnableReference(), ppIDst); } /// To be documented. [NativeName("Src", "Line 7420, Column 16 in wincodec.h")] - public static unsafe int WICConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, Span pISrc, ref IWICBitmapSource* ppIDst) + public static unsafe int ConvertBitmapSource(this WindowsCodecs thisApi, Span dstFormat, Span pISrc, ref IWICBitmapSource* ppIDst) { // SpanOverloader - return thisApi.WICConvertBitmapSource(ref dstFormat.GetPinnableReference(), ref pISrc.GetPinnableReference(), ref ppIDst); + return thisApi.ConvertBitmapSource(ref dstFormat.GetPinnableReference(), ref pISrc.GetPinnableReference(), ref ppIDst); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSection(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, ppIBitmap); + return thisApi.CreateBitmapFromSection(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSection(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, ref ppIBitmap); + return thisApi.CreateBitmapFromSection(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, ref ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) { // SpanOverloader - return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, ppIBitmap); + return thisApi.CreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) { // SpanOverloader - return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, ref ppIBitmap); + return thisApi.CreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, ref ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, IWICBitmap** ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, ppIBitmap); + return thisApi.CreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7425, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSection(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, ref ppIBitmap); + return thisApi.CreateBitmapFromSection(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, ref ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ppIBitmap); + return thisApi.CreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Guid* pixelFormat, Span hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ref ppIBitmap); + return thisApi.CreateBitmapFromSectionEx(width, height, pixelFormat, ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ref ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) + public static unsafe int CreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) { // SpanOverloader - return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, desiredAccessLevel, ppIBitmap); + return thisApi.CreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, desiredAccessLevel, ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) + public static unsafe int CreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, void* hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) { // SpanOverloader - return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, desiredAccessLevel, ref ppIBitmap); + return thisApi.CreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), hSection, stride, offset, desiredAccessLevel, ref ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, IWICBitmap** ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ppIBitmap); + return thisApi.CreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7434, Column 16 in wincodec.h")] - public static unsafe int WICCreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, WICSectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged + public static unsafe int CreateBitmapFromSectionEx(this WindowsCodecs thisApi, uint width, uint height, Span pixelFormat, Span hSection, uint stride, uint offset, SectionAccessLevel desiredAccessLevel, ref IWICBitmap* ppIBitmap) where T0 : unmanaged { // SpanOverloader - return thisApi.WICCreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ref ppIBitmap); + return thisApi.CreateBitmapFromSectionEx(width, height, ref pixelFormat.GetPinnableReference(), ref hSection.GetPinnableReference(), stride, offset, desiredAccessLevel, ref ppIBitmap); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(guid, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapGuidToShortName(guid, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(guid, cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapGuidToShortName(guid, cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(guid, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapGuidToShortName(guid, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Guid* guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(guid, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapGuidToShortName(guid, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, char* wzName, uint* pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, char* wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, pcchActual); + return thisApi.MapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapGuidToShortName(ref guid.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapGuidToShortName(ref guid.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, pcchActual); + return thisApi.MapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7444, Column 16 in wincodec.h")] - public static unsafe int WICMapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapGuidToShortName(this WindowsCodecs thisApi, Span guid, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapGuidToShortName(ref guid.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] - public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pguid) + public static unsafe int MapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] char* wzName, Span pguid) { // SpanOverloader - return thisApi.WICMapShortNameToGuid(wzName, ref pguid.GetPinnableReference()); + return thisApi.MapShortNameToGuid(wzName, ref pguid.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] - public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Guid* pguid) + public static unsafe int MapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Guid* pguid) { // SpanOverloader - return thisApi.WICMapShortNameToGuid(in wzName.GetPinnableReference(), pguid); + return thisApi.MapShortNameToGuid(in wzName.GetPinnableReference(), pguid); } /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] - public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pguid) + public static unsafe int MapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan wzName, Span pguid) { // SpanOverloader - return thisApi.WICMapShortNameToGuid(in wzName.GetPinnableReference(), ref pguid.GetPinnableReference()); + return thisApi.MapShortNameToGuid(in wzName.GetPinnableReference(), ref pguid.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7450, Column 16 in wincodec.h")] - public static unsafe int WICMapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pguid) + public static unsafe int MapShortNameToGuid(this WindowsCodecs thisApi, [Flow(Silk.NET.Core.Native.FlowDirection.In), UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pguid) { // SpanOverloader - return thisApi.WICMapShortNameToGuid(wzName, ref pguid.GetPinnableReference()); + return thisApi.MapShortNameToGuid(wzName, ref pguid.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Guid* guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(guidMetadataFormat, pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, char* pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, Span pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), ref pwzSchema.GetPinnableReference(), cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, char* wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, Span wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, ref wzName.GetPinnableReference(), ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, uint* pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, pcchActual); } /// To be documented. [NativeName("Src", "Line 7454, Column 16 in wincodec.h")] - public static unsafe int WICMapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) + public static unsafe int MapSchemaToName(this WindowsCodecs thisApi, Span guidMetadataFormat, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPWStr)] string pwzSchema, uint cchName, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string wzName, Span pcchActual) { // SpanOverloader - return thisApi.WICMapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); + return thisApi.MapSchemaToName(ref guidMetadataFormat.GetPinnableReference(), pwzSchema, cchName, wzName, ref pcchActual.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) + public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) { // SpanOverloader return thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(This, ref pInfo.GetPinnableReference()); @@ -850,7 +850,7 @@ public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, WICRawCapabilitiesInfo* pInfo) + public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, RawCapabilitiesInfo* pInfo) { // SpanOverloader return thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), pInfo); @@ -858,7 +858,7 @@ public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this /// To be documented. [NativeName("Src", "Line 8219, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, Span pInfo) + public static unsafe int IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, Span pInfo) { // SpanOverloader return thisApi.IWICDevelopRawRemoteQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), ref pInfo.GetPinnableReference()); @@ -986,7 +986,7 @@ public static unsafe void IWICDevelopRawRemoteQueryRawCapabilitiesInfoStub(this /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteSetToneCurveProxy(This, cPoints, in aPoints.GetPinnableReference()); @@ -994,7 +994,7 @@ public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) + public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteSetToneCurveProxy(ref This.GetPinnableReference(), cPoints, aPoints); @@ -1002,7 +1002,7 @@ public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8231, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + public static unsafe int IWICDevelopRawRemoteSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteSetToneCurveProxy(ref This.GetPinnableReference(), cPoints, in aPoints.GetPinnableReference()); @@ -1130,7 +1130,7 @@ public static unsafe void IWICDevelopRawRemoteSetToneCurveStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, WICRawToneCurvePoint** paPoints) + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, RawToneCurvePoint** paPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(This, ref pcPoints.GetPinnableReference(), paPoints); @@ -1138,7 +1138,7 @@ public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, ref RawToneCurvePoint* paPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(This, ref pcPoints.GetPinnableReference(), ref paPoints); @@ -1146,7 +1146,7 @@ public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint* pcPoints, WICRawToneCurvePoint** paPoints) + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint* pcPoints, RawToneCurvePoint** paPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), pcPoints, paPoints); @@ -1154,7 +1154,7 @@ public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint* pcPoints, ref RawToneCurvePoint* paPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), pcPoints, ref paPoints); @@ -1162,7 +1162,7 @@ public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, Span pcPoints, WICRawToneCurvePoint** paPoints) + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, Span pcPoints, RawToneCurvePoint** paPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), paPoints); @@ -1170,7 +1170,7 @@ public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 8244, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + public static unsafe int IWICDevelopRawRemoteGetToneCurveProxy(this WindowsCodecs thisApi, Span This, Span pcPoints, ref RawToneCurvePoint* paPoints) { // SpanOverloader return thisApi.IWICDevelopRawRemoteGetToneCurveProxy(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), ref paPoints); @@ -2098,162 +2098,162 @@ public static unsafe void LPSAFEARRAYUserFree(this WindowsCodecs thisApi, SpanTo be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] - public static unsafe uint WICInProcPointerUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, byte** arg2) + public static unsafe uint InProcPointerUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserSize(ref arg0.GetPinnableReference(), arg1, arg2); + return thisApi.InProcPointerUserSize(ref arg0.GetPinnableReference(), arg1, arg2); } /// To be documented. [NativeName("Src", "Line 9014, Column 39 in wincodec.h")] - public static unsafe uint WICInProcPointerUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref byte* arg2) + public static unsafe uint InProcPointerUserSize(this WindowsCodecs thisApi, Span arg0, uint arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); + return thisApi.InProcPointerUserSize(ref arg0.GetPinnableReference(), arg1, ref arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, byte** arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); + return thisApi.InProcPointerUserMarshal(arg0, ref arg1.GetPinnableReference(), arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + return thisApi.InProcPointerUserMarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, byte** arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + return thisApi.InProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + return thisApi.InProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, byte** arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + return thisApi.InProcPointerUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + return thisApi.InProcPointerUserMarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); + return thisApi.InProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, arg2); } /// To be documented. [NativeName("Src", "Line 9015, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserMarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + return thisApi.InProcPointerUserMarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, byte** arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); + return thisApi.InProcPointerUserUnmarshal(arg0, ref arg1.GetPinnableReference(), arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, uint* arg0, Span arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); + return thisApi.InProcPointerUserUnmarshal(arg0, ref arg1.GetPinnableReference(), ref arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, byte** arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + return thisApi.InProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, byte* arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + return thisApi.InProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, byte** arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); + return thisApi.InProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, Span arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); + return thisApi.InProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), ref arg1.GetPinnableReference(), ref arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, byte** arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); + return thisApi.InProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, arg2); } /// To be documented. [NativeName("Src", "Line 9016, Column 29 in wincodec.h")] - public static unsafe byte* WICInProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2) + public static unsafe byte* InProcPointerUserUnmarshal(this WindowsCodecs thisApi, Span arg0, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string arg1, ref byte* arg2) { // SpanOverloader - return thisApi.WICInProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); + return thisApi.InProcPointerUserUnmarshal(ref arg0.GetPinnableReference(), arg1, ref arg2); } /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] - public static unsafe void WICInProcPointerUserFree(this WindowsCodecs thisApi, Span arg0, byte** arg1) + public static unsafe void InProcPointerUserFree(this WindowsCodecs thisApi, Span arg0, byte** arg1) { // SpanOverloader - thisApi.WICInProcPointerUserFree(ref arg0.GetPinnableReference(), arg1); + thisApi.InProcPointerUserFree(ref arg0.GetPinnableReference(), arg1); } /// To be documented. [NativeName("Src", "Line 9017, Column 39 in wincodec.h")] - public static unsafe void WICInProcPointerUserFree(this WindowsCodecs thisApi, Span arg0, ref byte* arg1) + public static unsafe void InProcPointerUserFree(this WindowsCodecs thisApi, Span arg0, ref byte* arg1) { // SpanOverloader - thisApi.WICInProcPointerUserFree(ref arg0.GetPinnableReference(), ref arg1); + thisApi.InProcPointerUserFree(ref arg0.GetPinnableReference(), ref arg1); } /// To be documented. @@ -2306,7 +2306,7 @@ public static unsafe int IWICBitmapCodecProgressNotificationRegisterProgressNoti /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual.GetPinnableReference()); @@ -2314,7 +2314,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), pcbPatternsActual); @@ -2322,7 +2322,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, BitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); @@ -2330,7 +2330,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, pcbPatternsActual); @@ -2338,7 +2338,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, ref pcbPatternsActual.GetPinnableReference()); @@ -2346,7 +2346,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), pcbPatternsActual); @@ -2354,7 +2354,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(This, cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); @@ -2362,7 +2362,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, pcPatterns, pcbPatternsActual); @@ -2370,7 +2370,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, BitmapPattern* pPatterns, uint* pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, pcPatterns, ref pcbPatternsActual.GetPinnableReference()); @@ -2378,7 +2378,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, BitmapPattern* pPatterns, Span pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), pcbPatternsActual); @@ -2386,7 +2386,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, WICBitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, BitmapPattern* pPatterns, Span pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, pPatterns, ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); @@ -2394,7 +2394,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, pcbPatternsActual); @@ -2402,7 +2402,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, uint* pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), pcPatterns, ref pcbPatternsActual.GetPinnableReference()); @@ -2410,7 +2410,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, uint* pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), pcbPatternsActual); @@ -2418,7 +2418,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9033, Column 41 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) + public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, uint cbSizePatterns, Span pPatterns, Span pcPatterns, Span pcbPatternsActual) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsProxy(ref This.GetPinnableReference(), cbSizePatterns, ref pPatterns.GetPinnableReference(), ref pcPatterns.GetPinnableReference(), ref pcbPatternsActual.GetPinnableReference()); @@ -2426,7 +2426,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsProxy(this WindowsCodec /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, WICBitmapPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, BitmapPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsStub(This, ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2434,7 +2434,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICBitmapDecoderInfo* This, ref BitmapPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsStub(This, ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2442,7 +2442,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, BitmapPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ppPatterns, pcPatterns); @@ -2450,7 +2450,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, WICBitmapPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, BitmapPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2458,7 +2458,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, ref BitmapPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ref ppPatterns, pcPatterns); @@ -2466,7 +2466,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 9044, Column 43 in wincodec.h")] - public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, ref WICBitmapPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, ref BitmapPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICBitmapDecoderInfoGetPatternsStub(ref This.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2474,7 +2474,7 @@ public static unsafe int IWICBitmapDecoderInfoGetPatternsStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) { // SpanOverloader return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoProxy(This, ref pInfo.GetPinnableReference()); @@ -2482,7 +2482,7 @@ public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this Window /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, WICRawCapabilitiesInfo* pInfo) + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, RawCapabilitiesInfo* pInfo) { // SpanOverloader return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), pInfo); @@ -2490,7 +2490,7 @@ public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this Window /// To be documented. [NativeName("Src", "Line 9049, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, Span pInfo) + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this WindowsCodecs thisApi, Span This, Span pInfo) { // SpanOverloader return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoProxy(ref This.GetPinnableReference(), ref pInfo.GetPinnableReference()); @@ -2498,7 +2498,7 @@ public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoProxy(this Window /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pInfo) { // SpanOverloader return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoStub(This, ref pInfo.GetPinnableReference()); @@ -2506,7 +2506,7 @@ public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this Windows /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, WICRawCapabilitiesInfo* pInfo) + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, RawCapabilitiesInfo* pInfo) { // SpanOverloader return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), pInfo); @@ -2514,7 +2514,7 @@ public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this Windows /// To be documented. [NativeName("Src", "Line 9054, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span pInfo) + public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this WindowsCodecs thisApi, Span This, Span pInfo) { // SpanOverloader return thisApi.IWICDevelopRawQueryRawCapabilitiesInfoStub(ref This.GetPinnableReference(), ref pInfo.GetPinnableReference()); @@ -2522,7 +2522,7 @@ public static unsafe int IWICDevelopRawQueryRawCapabilitiesInfoStub(this Windows /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) + public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) { // SpanOverloader return thisApi.IWICDevelopRawSetToneCurveProxy(This, cbToneCurveSize, in pToneCurve.GetPinnableReference()); @@ -2530,7 +2530,7 @@ public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurve* pToneCurve) + public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurve* pToneCurve) { // SpanOverloader return thisApi.IWICDevelopRawSetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveSize, pToneCurve); @@ -2538,7 +2538,7 @@ public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9058, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) + public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveSize, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pToneCurve) { // SpanOverloader return thisApi.IWICDevelopRawSetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveSize, in pToneCurve.GetPinnableReference()); @@ -2546,7 +2546,7 @@ public static unsafe int IWICDevelopRawSetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) { // SpanOverloader return thisApi.IWICDevelopRawSetToneCurveStub(This, cPoints, in aPoints.GetPinnableReference()); @@ -2554,7 +2554,7 @@ public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] WICRawToneCurvePoint* aPoints) + public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] RawToneCurvePoint* aPoints) { // SpanOverloader return thisApi.IWICDevelopRawSetToneCurveStub(ref This.GetPinnableReference(), cPoints, aPoints); @@ -2562,7 +2562,7 @@ public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9065, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) + public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisApi, Span This, uint cPoints, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan aPoints) { // SpanOverloader return thisApi.IWICDevelopRawSetToneCurveStub(ref This.GetPinnableReference(), cPoints, in aPoints.GetPinnableReference()); @@ -2570,7 +2570,7 @@ public static unsafe int IWICDevelopRawSetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(This, cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize.GetPinnableReference()); @@ -2578,7 +2578,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(This, cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), pcbActualToneCurveBufferSize); @@ -2586,7 +2586,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, IWICDevelopRaw* This, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(This, cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), ref pcbActualToneCurveBufferSize.GetPinnableReference()); @@ -2594,7 +2594,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, uint* pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, pToneCurve, pcbActualToneCurveBufferSize); @@ -2602,7 +2602,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, WICRawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, RawToneCurve* pToneCurve, Span pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, pToneCurve, ref pcbActualToneCurveBufferSize.GetPinnableReference()); @@ -2610,7 +2610,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, Span pToneCurve, uint* pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), pcbActualToneCurveBufferSize); @@ -2618,7 +2618,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9070, Column 41 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) + public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs thisApi, Span This, uint cbToneCurveBufferSize, Span pToneCurve, Span pcbActualToneCurveBufferSize) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveProxy(ref This.GetPinnableReference(), cbToneCurveBufferSize, ref pToneCurve.GetPinnableReference(), ref pcbActualToneCurveBufferSize.GetPinnableReference()); @@ -2626,7 +2626,7 @@ public static unsafe int IWICDevelopRawGetToneCurveProxy(this WindowsCodecs this /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, WICRawToneCurvePoint** paPoints) + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, RawToneCurvePoint** paPoints) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveStub(This, ref pcPoints.GetPinnableReference(), paPoints); @@ -2634,7 +2634,7 @@ public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, IWICDevelopRaw* This, Span pcPoints, ref RawToneCurvePoint* paPoints) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveStub(This, ref pcPoints.GetPinnableReference(), ref paPoints); @@ -2642,7 +2642,7 @@ public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, uint* pcPoints, WICRawToneCurvePoint** paPoints) + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, uint* pcPoints, RawToneCurvePoint** paPoints) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), pcPoints, paPoints); @@ -2650,7 +2650,7 @@ public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, uint* pcPoints, ref WICRawToneCurvePoint* paPoints) + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, uint* pcPoints, ref RawToneCurvePoint* paPoints) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), pcPoints, ref paPoints); @@ -2658,7 +2658,7 @@ public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span pcPoints, WICRawToneCurvePoint** paPoints) + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span pcPoints, RawToneCurvePoint** paPoints) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), paPoints); @@ -2666,7 +2666,7 @@ public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 9079, Column 43 in wincodec.h")] - public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span pcPoints, ref WICRawToneCurvePoint* paPoints) + public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisApi, Span This, Span pcPoints, ref RawToneCurvePoint* paPoints) { // SpanOverloader return thisApi.IWICDevelopRawGetToneCurveStub(ref This.GetPinnableReference(), ref pcPoints.GetPinnableReference(), ref paPoints); @@ -2674,7 +2674,7 @@ public static unsafe int IWICDevelopRawGetToneCurveStub(this WindowsCodecs thisA /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2682,7 +2682,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2690,7 +2690,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); @@ -2698,7 +2698,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2706,7 +2706,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); @@ -2714,7 +2714,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2722,7 +2722,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, pcPatterns); @@ -2730,7 +2730,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2738,7 +2738,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, pcPatterns); @@ -2746,7 +2746,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2754,7 +2754,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); @@ -2762,7 +2762,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2770,7 +2770,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); @@ -2778,7 +2778,7 @@ public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this Windo /// To be documented. [NativeName("Src", "Line 1676, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoRemoteGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoRemoteGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -2906,7 +2906,7 @@ public static unsafe void IWICMetadataReaderInfoRemoteGetPatternsStub(this Windo /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(This, guidContainerFormat, ref pHeader.GetPinnableReference()); @@ -2914,7 +2914,7 @@ public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this Windows /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, WICMetadataHeader* pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, MetadataHeader* pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), pHeader); @@ -2922,7 +2922,7 @@ public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this Windows /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); @@ -2930,7 +2930,7 @@ public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this Windows /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, MetadataHeader* pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, pHeader); @@ -2938,7 +2938,7 @@ public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this Windows /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, ref pHeader.GetPinnableReference()); @@ -2946,7 +2946,7 @@ public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this Windows /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataHeader* pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, MetadataHeader* pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), pHeader); @@ -2954,7 +2954,7 @@ public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this Windows /// To be documented. [NativeName("Src", "Line 1947, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoRemoteGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoRemoteGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); @@ -3082,234 +3082,234 @@ public static unsafe void IWICMetadataWriterInfoRemoteGetHeaderStub(this Windows /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, pguidVendor, pIStream, ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(guidContainerFormat, pguidVendor, pIStream, ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, pguidVendor, ref pIStream.GetPinnableReference(), pguidMetadataFormat); + return thisApi.MatchMetadataContent(guidContainerFormat, pguidVendor, ref pIStream.GetPinnableReference(), pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, pguidVendor, ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(guidContainerFormat, pguidVendor, ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), pIStream, pguidMetadataFormat); + return thisApi.MatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), pIStream, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), pIStream, ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), pIStream, ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), pguidMetadataFormat); + return thisApi.MatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(guidContainerFormat, in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, pIStream, pguidMetadataFormat); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, pIStream, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, pIStream, ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, pIStream, ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref pIStream.GetPinnableReference(), pguidMetadataFormat); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref pIStream.GetPinnableReference(), pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Guid* pguidVendor, Span pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), pguidVendor, ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), pIStream, pguidMetadataFormat); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), pIStream, pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Silk.NET.Core.Win32Extras.IStream* pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), pIStream, ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), pIStream, ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Guid* pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Guid* pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), pguidMetadataFormat); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), pguidMetadataFormat); } /// To be documented. [NativeName("Src", "Line 2396, Column 16 in wincodecsdk.h")] - public static unsafe int WICMatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Span pguidMetadataFormat) + public static unsafe int MatchMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pguidVendor, Span pIStream, Span pguidMetadataFormat) { // SpanOverloader - return thisApi.WICMatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); + return thisApi.MatchMetadataContent(ref guidContainerFormat.GetPinnableReference(), in pguidVendor.GetPinnableReference(), ref pIStream.GetPinnableReference(), ref pguidMetadataFormat.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Span pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Span pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(guidContainerFormat, pIWriter, dwPersistOptions, ref pIStream.GetPinnableReference()); + return thisApi.SerializeMetadataContent(guidContainerFormat, pIWriter, dwPersistOptions, ref pIStream.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(guidContainerFormat, ref pIWriter.GetPinnableReference(), dwPersistOptions, pIStream); + return thisApi.SerializeMetadataContent(guidContainerFormat, ref pIWriter.GetPinnableReference(), dwPersistOptions, pIStream); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, uint dwPersistOptions, Span pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, uint dwPersistOptions, Span pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(guidContainerFormat, ref pIWriter.GetPinnableReference(), dwPersistOptions, ref pIStream.GetPinnableReference()); + return thisApi.SerializeMetadataContent(guidContainerFormat, ref pIWriter.GetPinnableReference(), dwPersistOptions, ref pIStream.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), pIWriter, dwPersistOptions, pIStream); + return thisApi.SerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), pIWriter, dwPersistOptions, pIStream); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Span pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, uint dwPersistOptions, Span pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), pIWriter, dwPersistOptions, ref pIStream.GetPinnableReference()); + return thisApi.SerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), pIWriter, dwPersistOptions, ref pIStream.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, uint dwPersistOptions, Silk.NET.Core.Win32Extras.IStream* pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), dwPersistOptions, pIStream); + return thisApi.SerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), dwPersistOptions, pIStream); } /// To be documented. [NativeName("Src", "Line 2402, Column 16 in wincodecsdk.h")] - public static unsafe int WICSerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, uint dwPersistOptions, Span pIStream) + public static unsafe int SerializeMetadataContent(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, uint dwPersistOptions, Span pIStream) { // SpanOverloader - return thisApi.WICSerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), dwPersistOptions, ref pIStream.GetPinnableReference()); + return thisApi.SerializeMetadataContent(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), dwPersistOptions, ref pIStream.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, Span pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, IWICMetadataWriter* pIWriter, Span pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(guidContainerFormat, pIWriter, ref pcbSize.GetPinnableReference()); + return thisApi.GetMetadataContentSize(guidContainerFormat, pIWriter, ref pcbSize.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, ulong* pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, ulong* pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(guidContainerFormat, ref pIWriter.GetPinnableReference(), pcbSize); + return thisApi.GetMetadataContentSize(guidContainerFormat, ref pIWriter.GetPinnableReference(), pcbSize); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, Span pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Guid* guidContainerFormat, Span pIWriter, Span pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(guidContainerFormat, ref pIWriter.GetPinnableReference(), ref pcbSize.GetPinnableReference()); + return thisApi.GetMetadataContentSize(guidContainerFormat, ref pIWriter.GetPinnableReference(), ref pcbSize.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, ulong* pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), pIWriter, pcbSize); + return thisApi.GetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), pIWriter, pcbSize); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, Span pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, IWICMetadataWriter* pIWriter, Span pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), pIWriter, ref pcbSize.GetPinnableReference()); + return thisApi.GetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), pIWriter, ref pcbSize.GetPinnableReference()); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, ulong* pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, ulong* pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), pcbSize); + return thisApi.GetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), pcbSize); } /// To be documented. [NativeName("Src", "Line 2408, Column 16 in wincodecsdk.h")] - public static unsafe int WICGetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, Span pcbSize) + public static unsafe int GetMetadataContentSize(this WindowsCodecs thisApi, Span guidContainerFormat, Span pIWriter, Span pcbSize) { // SpanOverloader - return thisApi.WICGetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), ref pcbSize.GetPinnableReference()); + return thisApi.GetMetadataContentSize(ref guidContainerFormat.GetPinnableReference(), ref pIWriter.GetPinnableReference(), ref pcbSize.GetPinnableReference()); } /// To be documented. @@ -3522,7 +3522,7 @@ public static unsafe void CLIPFORMATUserFree(this WindowsCodecs thisApi, SpanTo be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); @@ -3530,7 +3530,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); @@ -3538,7 +3538,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3546,7 +3546,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); @@ -3554,7 +3554,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); @@ -3562,7 +3562,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); @@ -3570,7 +3570,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3578,7 +3578,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, pcbActual); @@ -3586,7 +3586,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); @@ -3594,7 +3594,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); @@ -3602,7 +3602,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3610,7 +3610,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); @@ -3618,7 +3618,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); @@ -3626,7 +3626,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); @@ -3634,7 +3634,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3642,7 +3642,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, pcCount, pcbActual); @@ -3650,7 +3650,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); @@ -3658,7 +3658,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); @@ -3666,7 +3666,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3674,7 +3674,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); @@ -3682,7 +3682,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); @@ -3690,7 +3690,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); @@ -3698,7 +3698,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3706,7 +3706,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, pcbActual); @@ -3714,7 +3714,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, pcCount, ref pcbActual.GetPinnableReference()); @@ -3722,7 +3722,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), pcbActual); @@ -3730,7 +3730,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataPattern* pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, MetadataPattern* pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pPattern, ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3738,7 +3738,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, pcbActual); @@ -3746,7 +3746,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, uint* pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), pcCount, ref pcbActual.GetPinnableReference()); @@ -3754,7 +3754,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), pcbActual); @@ -3762,7 +3762,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2435, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) + public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pPattern, Span pcCount, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pPattern.GetPinnableReference(), ref pcCount.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3770,7 +3770,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsProxy(this WindowsCode /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3778,7 +3778,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3786,7 +3786,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); @@ -3794,7 +3794,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3802,7 +3802,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); @@ -3810,7 +3810,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, IWICMetadataReaderInfo* This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(This, ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3818,7 +3818,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, pcPatterns); @@ -3826,7 +3826,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3834,7 +3834,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, pcPatterns); @@ -3842,7 +3842,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), guidContainerFormat, ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3850,7 +3850,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, MetadataPattern** ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, pcPatterns); @@ -3858,7 +3858,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataPattern** ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, MetadataPattern** ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3866,7 +3866,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, uint* pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, uint* pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, pcPatterns); @@ -3874,7 +3874,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2447, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref WICMetadataPattern* ppPatterns, Span pcPatterns) + public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, ref MetadataPattern* ppPatterns, Span pcPatterns) { // SpanOverloader return thisApi.IWICMetadataReaderInfoGetPatternsStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref ppPatterns, ref pcPatterns.GetPinnableReference()); @@ -3882,7 +3882,7 @@ public static unsafe int IWICMetadataReaderInfoGetPatternsStub(this WindowsCodec /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, guidContainerFormat, cbSize, pHeader, ref pcbActual.GetPinnableReference()); @@ -3890,7 +3890,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), pcbActual); @@ -3898,7 +3898,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3906,7 +3906,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, pcbActual); @@ -3914,7 +3914,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, MetadataHeader* pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, ref pcbActual.GetPinnableReference()); @@ -3922,7 +3922,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), pcbActual); @@ -3930,7 +3930,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(This, ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3938,7 +3938,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pHeader, pcbActual); @@ -3946,7 +3946,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, MetadataHeader* pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, pHeader, ref pcbActual.GetPinnableReference()); @@ -3954,7 +3954,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), pcbActual); @@ -3962,7 +3962,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), guidContainerFormat, cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -3970,7 +3970,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, MetadataHeader* pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, pcbActual); @@ -3978,7 +3978,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, WICMetadataHeader* pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, MetadataHeader* pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, pHeader, ref pcbActual.GetPinnableReference()); @@ -3986,7 +3986,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pHeader, uint* pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), pcbActual); @@ -3994,7 +3994,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2453, Column 41 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) + public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, uint cbSize, Span pHeader, Span pcbActual) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderProxy(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), cbSize, ref pHeader.GetPinnableReference(), ref pcbActual.GetPinnableReference()); @@ -4002,7 +4002,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderProxy(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Guid* guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(This, guidContainerFormat, ref pHeader.GetPinnableReference()); @@ -4010,7 +4010,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, WICMetadataHeader* pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, MetadataHeader* pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(This, ref guidContainerFormat.GetPinnableReference(), pHeader); @@ -4018,7 +4018,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, IWICMetadataWriterInfo* This, Span guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(This, ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); @@ -4026,7 +4026,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, WICMetadataHeader* pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, MetadataHeader* pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), guidContainerFormat, pHeader); @@ -4034,7 +4034,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Guid* guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), guidContainerFormat, ref pHeader.GetPinnableReference()); @@ -4042,7 +4042,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, WICMetadataHeader* pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, MetadataHeader* pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), pHeader); @@ -4050,7 +4050,7 @@ public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs /// To be documented. [NativeName("Src", "Line 2463, Column 43 in wincodecsdk.h")] - public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, Span pHeader) + public static unsafe int IWICMetadataWriterInfoGetHeaderStub(this WindowsCodecs thisApi, Span This, Span guidContainerFormat, Span pHeader) { // SpanOverloader return thisApi.IWICMetadataWriterInfoGetHeaderStub(ref This.GetPinnableReference(), ref guidContainerFormat.GetPinnableReference(), ref pHeader.GetPinnableReference()); From 50951e66f3ddeaec438b6df0835f838fad23dbf8 Mon Sep 17 00:00:00 2001 From: Steven He Date: Sat, 23 Sep 2023 17:57:42 +0900 Subject: [PATCH 5/7] Fix naming conflict for ProgressNotification --- build/cache/wic.json.gz | Bin 59823 -> 59823 bytes generator.json | 4 +++- ...gen.cs => ProgressNotificationEnum.gen.cs} | 2 +- 3 files changed, 4 insertions(+), 2 deletions(-) rename src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/{ProgressNotification.gen.cs => ProgressNotificationEnum.gen.cs} (95%) diff --git a/build/cache/wic.json.gz b/build/cache/wic.json.gz index fa5988956f320fdd00bd83b81a9f840d9e534b70..21dba4547f3a611fa98895d19a7904c75b358117 100644 GIT binary patch delta 54110 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
  • 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 diff --git a/generator.json b/generator.json index f90247a0ef..fe46906e71 100644 --- a/generator.json +++ b/generator.json @@ -1628,7 +1628,9 @@ "ID2D1Device", "ID2D1Image" ], - "rename": {}, + "rename": { + "WICProgressNotification": "ProgressNotificationEnum" + }, "bakery": { "profileNames": [ "silk.net.windowscodecs", diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotification.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotificationEnum.gen.cs similarity index 95% rename from src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotification.gen.cs rename to src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotificationEnum.gen.cs index 1e097b9326..bcff9094f7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotification.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Enums/ProgressNotificationEnum.gen.cs @@ -11,7 +11,7 @@ namespace Silk.NET.WindowsCodecs { [Flags] [NativeName("Name", "WICProgressNotification")] - public enum ProgressNotification : int + public enum ProgressNotificationEnum : int { [NativeName("Name", "")] None = 0, From eb9be281ed50825142cce0e48a0f2e64574e2473 Mon Sep 17 00:00:00 2001 From: Steven He Date: Sat, 23 Sep 2023 18:02:26 +0900 Subject: [PATCH 6/7] Tweaks --- build/cache/win32extras.json.gz | Bin 280774 -> 280774 bytes generator.json | 3 +-- .../Enums/{AdviseFlag.gen.cs => ADVF.gen.cs} | 2 +- 3 files changed, 2 insertions(+), 3 deletions(-) rename src/Core/Silk.NET.Core.Win32Extras/Enums/{AdviseFlag.gen.cs => ADVF.gen.cs} (98%) diff --git a/build/cache/win32extras.json.gz b/build/cache/win32extras.json.gz index cf699e1870d1263aa9661b6c61ba20e82cbbfc16..2da914163dac8f9d74cb9541a0c838ef6741fb87 100644 GIT binary patch delta 266756 zcmYJZ18^W+*EJeWoJ=yYZQHhO+qOEHOp=)x6Wg|J+qP}%pXdE<)vfMY-DjPyQ>VJS zYVW<)9*jjEj76?SB>=h-kv%!1kzMm~T_gAtZ_mAqHpkjAUwbMdq=~hf*Vf%#gR(F&RfeE)i z@x+rU{)B$5M0A{I;*`e-r3&i}ChZCvUmMEZMK@N3)gwNoO@Qa$7K4JTxj3#nnA35M z(fK3wl^<8EZxz^mMZ4{CTW$>$Qxugs9rQ=GtJoVy^6?U>PiC(>MQkqoMtaQ1?0Op* z=;R~5N&YZ2FGS>WBbqEd*b(t5c!Ax-SU-rqYmgR>LB2oEo#-Nm@`6HQZNO|P?9G?T zk~Z>`EFwz=X#!hAzeO9Tki+tE!xZn03NaOG9RNk$oK5T)Wv;RZS$qc@9E1He;3VlBRAS zIdUzm>Y-b04In5TS91a`qD2If+wLVNT^hCQBz5o!n@oPQ4z6bvmnslahwut`>qary zosUY-#&j;Cg%FW)ANg@f!tRWj<;p)=l9;I`NSr+hks*m34Y%KMvBYJrLCibes1BkI7rbCK1Tfn=1+rbYM3g{FrJdOGk{Sct@$yOM|x0%mHrVn+$Y zHkiw(^T2louTe!$sC#(qua#n^1pVvmdA>0^x*XE9!BFYW-XwjG85V3`2MvjG2%qKZ zdA|uhG1=KUWV=9>U@GXW0H~N$U+7=kji@R%JwP?;+g5OeWViag9S1Qbx`*%2?^A51 zs*S|A;H4{-H$-f_SDcQriNbfP=#QpKBO{s&*?(|bwmB=Hx?uJGrqgRzVzB-3&657W zj&gMkQ6SYPf{eEtVy=e##Y5}1fX)MDjp7@bE+1Zm;GQHZ z8iphEv&7X#XD3sd^H5{E9{+RmIVjJo<#8mqg~A2-=n zEU}qwB)s(B2I5%=-E1U)tfGx37vC9Z+pg=OxpN|4ZLA<=4y!e;Uo*V0d7h~9RSuHC zDZ347(4s@w3pZ)j1BV(MKDM}ki{q(ho(H{bCTV>NWVsuxj(j&KMJpAtj?tCxBysb> z^LFM3IGdk{162(W8VDUx(l&iH|9k9On1KlEsncx)P=ZdG4*u(^c3w*c+ceTxb?iWG zR}rQc#)^+n+7NQk=0vX$#?Hxup~(z*GRAC5jK;N&%NUr*AbJIzHr*625RvsRAm*)^ zjVlxY&qo2f!y1-kl<34mMzyt;u|MSPFOFk{1p3F)5w1H)?{gbq6>!WR-^AJZSHrsQ z7+iiy_=64MCXG1)Y;Yy!QPAmzqVwFjP5ZCb63szJ%><~Na$nVZ&ghFxNOC}&T`oXk zFmym}^4+Eov@c3Vc6sZwhW()6VJSpBhoa031(+1-OR0;#1&xgeNkYsmlsZi=KTOY$ z(V3_7jaTKz`#0+<`Xcz=h{(^KPEhT4kXku`)(LVmR7(j>Fp>6|v3*|>7RLS(6q}=B z5pf{LyISG*s6bn!Zcght3498TpWKEHIDn0%mi&17HL)NN!J_jixapgxcV=;gyOLkr zSbBP;J9b3Sw;r^v)NZAor*KzhtJpVrQ1r%U<9&|YUcxt6?Gw_e72J%tNhF&#gwvm9 zB4--qd)323>KTRnq8ZIUB(hWE|C38@k#bQsXz+%7?Ki)c^k?P!9+1eTvh{tDwI#^Y z#dc6ptTyME#Y{V1{ctclGYl*DK1iTjRbhsoc=|Ut3RjKfA1QHF6yxUMh+K->310AV z{Lz~3o}iZa=pD9r@1#cgXqs%`=W$(A}WjKzR2L~j|?U8qRarJ ziO{6VU6ktvlu)k4W6X1>NQI8nAig|7^oD{4EspyI=}fH@B77IjJx*H~%oJ~>P!IZ^ z@@b5F=U59ZVt@%W2`N*Em)tR=V3Tc`Ep~gt_y|6;Lfl_9;5XZjJ=&w@rZ^0KhWD1? zqVMt%(^Q2vq_iV*?j1y!+hlGSancFyIExtHPO5%=_4D~#Gj12x4S!SDm$UyxeEfD3 zPVlNdd1+SE6Z433jHe$9+XnTc9J}ftd!jAl`%d<67l3t_!`AuUr@u}L2bxyKioww* zlLY0t(xUX&>(vyUUE%ivIXCIFMoC>AH)6HE82(e!H|;HZ0T=UZJ5)H$W317ihMuK& z&jlN2{E=^YJv}sVKes-&A9L{fIFXRr-7LZ?9`>Mi^7}+yuQmsHpEYE7o`;Urw5~o^ z)-BPo{D2HuMfQ+U;dn~n){hGH`Q`2q`E&)YeJw9-W}hqX=gc)Ef1kzbEq-Nd+$MuX6blb5-)N(qw{P2dZ6$kP00?r$%=Zn!+kQFskD^GBODjqYuVC z-4A-a!UB00B3F_zBR#~@ByGIbJ3H`}?C)9(JOERlB<JujN}(nceBMsij&h3GAP2{A(|zz!`!wH3A~| z3()I$tudu3LEAV!lBubA`Au|>bH?z+MQFF@_9hA)xfW=D1lnlQ0e?1%(vPOpPG8c? zq`UXvzerac(hg)FQ|1bfT`y6YJk$~UhXY~gPeWJ70UMLfFdiqay=O#<;~5<|OZc}X zkW=TAnYx(Ux1vs7+eh6~fi5bhT^#)_fYeOhibq7#_G#mNj)O0IxBqKe?u5V9d%oWk z8pXZTEEdYmZ(M~P+-EN#vXwSLssU@wdX=&)T~Q?jlqvvXe{nGK(()P)s}XfU)TiMp z?k(+H2RGr4`-fKQwxclWgAK>m+IF=Lb(4_F7qZA&FPNpA}!eLc2edyfFYek z9iT|h92R%@d=}!Ak{)Ydd&%C}N~*h#O)|c_XapsX1<7h5@F$4E##?1N(9P+7RpY>9 zPBuV(f7DC#Wn5}I%OTO!LVyTsGR4zl@l)zs;F#}aGI&L~Su z%PYjRSsros4*n!Eo?PFij!GMeB zl%*NlT$p*(|3S;A67dsIYN7e?uvb0qk}9CpLTYo{J~Du@yH99jC!63MXVS6bLF^p# zmmamquz_z>NrS=TAn-O%|(Q|cdR z2^%^mwFGqU(|dm%z{RI^YC}G6rn(0>mjpS}XBxyMgCz1$&^}$DIJVd|S!rq4Oc`9I z%5s!`{8BK?1C1R^Z_q%cc_5f_ld=JZ z@8*+QrW5S++0{5$R{XDJPLiY# zDwRJ6yc@J;zb?gYla>rHROCqEyX|=xXcfY{Ap6J01N=b#V5` zn{Z5q>^CQ`;fH${9o6@Y1Ep=kb~|WX){YepYfnU%c(h&Qfn6UgQLu`re(<$0pu1 zIG3*78J*D>!-w;I#N?Ay6LL`b*`lAE&D`{E{ba$Q{9Fi;tgS+UEFnOR#b<{5)i&=n zyJA~t4RQkwZyEPGxK786(SA<~BY= z{z~gpZqvmF>{SOAK{f-PRd_X~*T>AV;*~53>fg#9sb_LJY01tGN*t&AWe5)e?JZw6 zQ!DXPDR>t_VjQu%nPmdLcu^@oUR*V(yqoMNW^1?jw%{KrTuslh$8$^2+T6b8ce9`H ze+O3hP;S-u6&D=^_(sB&zBqr_k zncB59NzZ)Bt)+IWSxCL+K&-8=Uce=Bx%!eFhdcVss6Kf347D^;vpxHX=&wA?whGOn zung3Ec6RJ&Lx{f{U%bYr^I`(Hs9uj_z`NgDn8o@C>gKR!+3${B4G!Q<_6O^tL9vao z$7}YNbu8{5)-$WqA%7cd2hj_ywwaitQH3{(&nL?a8>;+MTk-IV57?v^_aZy4QR+IU z{EHqg$cG&I^+p#=-{yI}K#Nr1$;+`aH0h-4qA+bp%!NJCVWWMj#uZ4>;qI4BYB^e^ zv4-%uTU6F&+$CEaD<6`Egt+vmgl=$bZhL6d@G2n8y`lx&)no1b3xzgg7E7+x>QhhTd*Mw>m<;}U-i?QIO9s*{7oQ)y zXsMAJ>XTECaE_AtyAA$i`DR^99Cbr@O-|`>V3RxID^7iFv!589Ax`w0rcG$>)tuMb zpkAcJ*%*q51-mg+`aOo7E~X>_GD&m<5yAqE0gN^u&HxRO4o51e*$q^)S@1};3>vyS zRqa%>qjjtcCAm+?^F{d8#ALVQv&)Dwa;4yNK`&PVoP0FQVwuRua6+%){H=Fg#klb= z+^}DLuvMI%1P*uQvW>c>n2ck}?R2+o!N|dQJng;Pz|L>*Xs#sc@9oaW(XtTp;roiT zh|4=@@W3LC1S^=QYsqZQ6u!^?4xwLq-@_53D>+putI~la4IVdk8IW=bdo!L~h^ z-Z8&M^F*CppgYyVb)uvR z4OpOvW_?6aZ?!C92>Hd+T5}m6Fxp_f35kf8bQ5;nOLzXSNFmUo_t|M58}ag?qG*=X zdUgv=47>6Vc60ZAuUP1)j7Y0+H_^q572V&1D*?(hB-GL`q|apk*u*ZDmnEcJu~f>1 zguU)1*_+(U$Z_l&&{~mV@r!7G37;^H02c49Az?ek3nM3x;&OAP0%QgPwIv=+AckFT z>MsE-n#bo1t~%OjkK!f_Y)5?PZzvvYdgBfu#-r~Ik6n|W${3S)=gNJeRpVaj=%0`H z<4IUeJp+2Zjh~ZxJ$)WYyAuNbyfUk@2~-H618RFiS0-mxX{g1)S&A?d}fjCSf5Fyi*K15tBUH8@Q0D}EigFp!Jgr~MT$R?%e&Z9yH0 z$3r`@w;dUE%kw79e)vmal+iJP7R975I&`M8@Zq_F&ZMND?hi-WJ_TJPA=DM>w-LSr zVTJH+cG(WHVt0Y(7yef^CexLVz+2?&zi57M6)<~-uR8;KOcM#qX`*yXAL;r$o+$9f zQoVmvslkeFHfWu|Qmft5BzW&W8aR`&FNm}6enK5lP^Q~2Zn8zN=arf_fIYll=9_}u z_i;}OH~6n8YgU?H`8}V7f0wt}~lSYG;XbKc+FJ(Vz>euUfLf0_}H> z4mN9spvB|2PD8)ssf#szfC+22<(;3x>DW5>i zDDJ%p^&-#ZI5s_IzXbR%WB)Qf4XCeT-t~V;z54BzY3y*XYzBY=tRBN z%@stxl#UPoJ!W_%4Ay@zyI(KmXeBY0{-L7W06!xFi{lZt@S43 zp*z)hRQROZ9I-tIa35!Ev6&bojC#6wUh)Mk<|nsRRx*$cY;`Yupz<)}oeggKjC(Bm zVXgc5{i_k(`aGomTyeP@nlD9lKyf)tb;9j*H!FZuf7c)%_P&oRKwYV}_wdNYZlmHG z%~uY5C^KcM-&vbSI(pko#~YN8j;!$noH4GZWa%=Y#TPFDfJD=lpCtA3?RARiqSEqS z3TymtuyF-g$oVZ5VrVta6yC`)>>P?m6ti0w&s)?l?gv^!n-<~+9d6_>x}P09j9|ub}qfsx&xK~$-MqKi0lt7wG5DPyn-`-8Ww%ZCRnvqpu*fPn8mq+EO?CHzs z=u&xwsH$69qa)~sjq6`t&;%XeJBf1>0&8vM>N$8s!^xs=WYFcBdD8Z zqq}TGHefP-B!Ji|(h_TiIrl)5JqU-@!R}kS`Z7FWxtO44peJc~<00Bjwh>gqU5e?m zeDX5UQ1ydBq_>;k8DGqmQ0LLGuY$eG`*=M+1D1;}n1EFVW4?EI8EQF+z%=YI7{z{` zpa>)I9IK@_v)BNsp{8hnl?s-+``7D7acB}A4s#h==ASYX$A#XzCw~)=4v>!TIt#H)PGE8^!>v2Wk_#Wb0Vo5 z&0d&hm-)GodaF?9a7<$`n!!eh8OHnYSI%S)NUdSP+7f-5n&Ro&+&5^aYSqthOJwu2 z%V62Z9m8k;W`F~ZJ1&1GI40PbXnNR&X*B4WaFb^-z`HTVGn-c9(jF_1u<9M?XI#B@ zey}*G6AFqY?R4O?!;jZ|Fk*(9bI^MAtgfT}99Hk_WC5mwH=@}k-3dMlH5EVdU1PTi zkaG`LiZU(hs70TtgD8EoB3>$S9I&Dw>~b*O%M-K8l=&6a#pTfjO@mmt>50!8!f-Kj zV1u{>_NwXO*fa(jiZBr8W;FIH%F!BKprXxrSF%tFypA3D+NBnjcC9HN#_fX_G-`Lm z#{9m%zAI6SdAOf5_|pEK7+3O$;AM6Us74-tgJHG^%cJqlZ~2v$V?kSY{c;6-y%l|F zIwZ=BJU;^@A9JFgtaC++8FIJhNng)zk7!euF;wj{iLmvfWxE=Vz}x#jZK%9UQOtY; z-Rh&P0e^V5yr_i0XVTi?b>6y5$TFQq;3A9jd)~iH8RNt6mcuX5)hN2;Rl@$5-5(T9l1hBk4@T?J~VAI5|^T)<$X@qTw;d5JGGwpUa7;Dp*ev zYOw%~2=9bKci59YKibEUXh#^(|Fs(gm*V&v9OL$0HyF;#n#qk?XdpWOZtnA%h+!7WZEipRILZeQ+>75;JPN(a(#cC z{X3%TG&Y8Q@IBYlMRnEd*At|ER{Cvb=)ddMe(4&_e64<^*ngRSwY0q9dUn>7-N|#} zclKaOq&xNh2kq(k0NNyHE-9)7uG1j01ujD&EvN;q0yfU@+{wp=h?g@P-4wY7N1fHl z>F1+*XKP!=mYjpb*zEfu5hr^wJ*wI!WXI)k_Xpw)=q`9a)NiEk1ldrdX82elNT~OM zLP)6nPy>IE@a;`Yn7x`?;s^@o%F>`x4iOLUXtX-pQly{mfVB}3DpGzzr>!)$tioKB zic2Jvcku62gvx^X0g|AxV8oE3u*ZqN?f?7(S>e+Slq@p4!cm_uT(m$YXBGIv8)~qp zpz^v=%LljAIbs#J$ii(3`edwO8nx6>)aBxmGj#8goqNf1eQSw?n#8W(Nj2OBrJZdO zhz20uVD}KfG0gOjYzjezfJ_iR(0|N5O_-*W(h%8#*j{cFOD0vX7@p-?;sJ}pacxAS z9fl+84-B{MTtwY@CwUAM47cv!aozNw$*v;{YF)|Z7>w#CCnYF)pFT0XBNrkkB?U^e;TkN_m&%V@glqn)z5vdnK>EFbzWTBFLOiS=8C_UO@he1`yc4b z(;?ZP36e(Gw>MXSH@R&$My=m3mvUcv9;>C9F(dyc(vQw&-mInu-my8fE}UA@U;$7H z0v`|CFY!4J>KOFmI#D%kR&o?W_fxa%riK3eh&o>jn9=lE(PF(LRbmYFo8N|)V`qA9 z=%zR|H1;IVON0RrJhl`(QU2>)c4OhmK}Z zEJt#AXm<=L;}sey7%OD9OBYs-69Z8DJ!x?*WE)6#)dWbGAqamEyl%CVEVQ)UQ025T z`<2lL9UiJD;O0;}2ubwEPL##kVNEP2-G>N|TC1@8p0L%hibn<2zLhf9W|IE9-qJUd zytI2wuSB$_zuaGr=C1IZB@f=jg5fCpSUt5WaKWKH(vIcf!l;{lPoB{p1Pbk!pFFW( zh=iwt2CoY;ME)*L@o!#OxOv&dHLx9I{S~0tta)(g5c;@n3IArNwQWt80(W42VN{kG z%1rkcgUoqvrGxWb6rn`OOk#;uN73&)stdFsWw&BL4v2`^MlwjqPrq;QkeINH^N=BM z0Xf1*P!s0#O}xm8EEM1WU;sECOi_`1$o*E*;-GHaN=qDGbT|&q(89`w$dLRfY=Phv z9={NR4`n*G$XK_eUbq}&Y+Pt2O685_NNmG!?EU859$I&sn4&xMamdM=B(|f1wh4X_ zJx_|WC2XNFoZCx>BaXZ^4t6!61g(iVEABTMxuI| zGNwdjqLdie38x!P_KDG9Eha%4jwOVoHJ&}YXF3ZPY47xVQ;r$4a9l-orBGnS_?WZHWcl*_R&)4nd;EzXpp85%C_e`A3Nb z1z&t;Y-V?V2Rz8F!&gdq-74Djl%DPx{HXhDmvHezL}KBzu^)lk32}_j`g(w+3cl>F zA51xfCQLPoA(<8jVKHB*+&6XSOJ;?7K|wf(`Amv{1m027RRG-3xjn8Hlk1x;*fK=* zNWm83tSYP72W*As&&gMG3X?K1kZcgaDP>4n0?2?y+8Ofgmrl_+J?cXM2@{o((onHG zJ3z<-1B;l=OXO65I+=XAbF%sSA*K#UM7W z0L4;I?Ayeu3)H^%W)7)^Cqy4>m)a%rX7_&}62b_g1dxJA(T}1(k$({%VxVI^tbs@= z(uABj*W%lOlEQ#XwLWgpaf)K7h2e%c$&Zg%gK_Mj-gT$fK%1G9rO3+wbeT3XkWEx+ za~dy{APj>3PTWjGo^$$fAp(EV&ZXe1`i(HpVJ2a-fKsDFBZb2T_$PY(7(*A@Xb$Vm zFc>Adg@zyNW7>p7tIiQB&>eA70n_PjCsL44w5tk}Za%)M~%NdHY;^(+4(-6|k`DXfay2^C!Z z&~F2na1mhRU4^NUl2MesEFSq{M!|c1cH6FEMtR6l1*wrr+GQjUE^f)nWivle{_v9C zdj4rAnLI-j`zI)* zr@Sy?SP1uIMmooH7x5dNTmQ1T*(sf~hgOD8#@VIBG?3BkUgD(2QR$37I`9HtZ4p;3 zy>x_pdxq^V4TU>?{-wbtt}?4A$M5m#!^;4V;13VSokVkgG3Fvftc4+~5mg^Ex*Q8g z)h895%=0NS2H6Onj`Z;2>A&=!diu?Ma0^3PjdolPH=$!{D%{a}856~tM|CMQrO`9W z$EeP~PWS4uRdQZ27lu|mY83%L_^O9rPl4I5oRv9(4@{-e43v}-4@?13bMCF!qqj(e zZBDO~EAS=+8Yv~C`FUMR<+_{|gY@I$E_&w8jcFZg`5B+(Cirs+$mLM6bCvI#OH1h3 z9`m4yl)?R6e3l71^Sal!r8&0TV)MhO;!PAfnKg1@9V!__lutwWXstl|>Gn@9zXzt- z8nM0lg7w-67jZ8;`skYMcM{w;VO)nQ={GT>@zar4J=E)Y74Bu0_HI%mY)1}&{}Ds! ztwWc(*_<=;!(DT*aV!6E6@TWR7E#gptzYr}`AOf_0r59GM>WTunl&fwn90g=P%`EW zi6*$05x9$>a&A~$xE-L&Siq6B#-T>|ThK7^rrY*W-fY#14Xi5vSYJx3I{8CP#YjnX zRFW?uNDg$_X=l1BW8lp9#)EZ>2SB0b+!`7qiEY{r!=e` zJ}DJ+;^UmAw0UWu_58Hx~xM;3EcxWdZXpv6$+m}R$VxLOBy zDI)fVZ{@#M!2(bvJJSKy-K~}52pcAgcjU=Z@0GuwyT%r+8V^n^6lGU>Qd4td>+uX1 z`cG6@J~iw{RlwT(o9~j+nmHu;F{CMrHy%!Cw`XS3Ux2yxPbi^4~Ng?7J5Mb zKe=R6dy`ctlJ#y{=bgF)=Ve>wyeKkj{=4$x1>emqF%xuo3uG& z_n!5Wc-u=|=Y55|uvwxdPOf=BV<}9NNAu$36bK5Tgf?HrW&v}`L>jVj{l@~<$A`HJ z^^Z9NSfF>tn8OTrbk&wn!K}6=2Ta2W+Yav*LHb%(h-x5%<18<#>dwVDxQ2S*l6jfc z6ieUmJfL@g-BQqYd7ir^_BoHfY9jUJ2fs`N!kICSMc?FR1rfK>oWR6fnp#&uTS3z8w+ zBf6SmulqP+{n<3}Nr1(;{|XHQORmTm`-?KikQn?E6P7%NRL2HOizJt!+33jR+n>q)X%YOiN@JP!1onqZ2U;hmW9{#bYK1`BUjq9|X|fVl zKgx;1r+6>N6_x**KSgu~uElfSVGa~10YLagWswBouKGRiZQLa^YIx0x^JJmro!hb9Md>s4zDDv`SG;4B+ z;oE^i5lh)W5us0@e*u-MEdVMnu{p~_Z`Dht!Gc7n88GFatJ=Td% zt_a>l8)CSCpREnz+IH>0`hD)TNC&6!pbIdJ{(=?Xb_U7 zTW}q7b~58u+2PYMFT6%RO#I?ReD$%Wo>5R>n<(;Q8z2eU)N< z`uK5{p%jH+x~I~HBs40ZUe_|K}IB5X*gx>bpBx)x@aBPUrWmx{$ zW^|yDu|5aaP4ye|PAz!^NZi1!56%B75x&tZw-sgtHpc^S zbKy-|)&^=V8GjwFqzlTFTYP2KG!iPwfxFrBQq{P8Wh-Zav?=PGi?R@cRH~2jQMe6N zTd3}(u2BI9g!1Wb*#Cg~Ob`NF6Ld`ooQAbp7`#j-6zYkut9?fZKgPUA^>C7`iO&^; zo(W=fibs%M^83JAR``sL!a*9s;%8b{1|7ct=RqJKbYhd|FKCV`D~Dg@Vy+Q zg68a`q>)IKWg%reVACd=zG{N)uoovh+k_9Et~Z#QB6@b zkAF$JrkMyiH1CxN*L46z2c-qmgs6r#MDETVs~-gk2l>aerZa*j5Q2oyf`&`FviLp@;W=T?9q+2jF-r|5tBG8o-d9fj18as;E00ufvcCvhRP);CMuX<~5T)`X7KC z|1)abBl^(ijW9a3?W<0?N_DOH(HJyNkpLkQPpF#TNYybKqI7a%h;$?G7NEI0* zs1KYQ*&2agTJx>wB3z!Pbu&a=|JP3V$B>?tdZq1Zm6ia_MWS89vxJefMiunQ?7*eQ zIzH#N=qe<(Z+YDp?KH3`+8yDG z{ArRV1xlvuzAn0hH(!QzlnxR#@jRP4Z>gVn{;KEH!xpGfR*Z&`4RjcG=T9S0)5z0H zmnmuo&z7=khnB(qA;>hH6IyhXq&C)G?Bj4ZcQ+B^GFL8IrSeu!Hn}Lyk)Cd-kSW{; zBx|elzoDM&@)|Hn`_dLHtImJWK~+;Yo&O1UW29oFO0vl}QjRk^xk;MYUiKp@%WXGr zElV4Hhd8o=bvcO$wPT!OoJz8hDU7!yG6*dbMD56H24Q%J`h&Zglq)gAM5|2lZ z!tIkM=g5MJ+>!B7{qB$6##O0@0DZ*-6h0jr;j~M5Mkf_MZS(c|w3AW=KS4VjExYeF zu88~nN^T2!g`SttwNDRi#v18~2)C@cvZ#)PKb3=s(}G_FjRPTdY9YsdARo5W3rHpg z2XB%%cgN|e6hBZt@%JW4sO(%%sHz%0IC(!6N=>SgE|8W=-5N2VzDwJ#6mO*lG&l}v z+)mG}l(vLwT3_3AVO6x@eJ%!@Uzxq_T_q~C-R4i-hWZA#ZORroRpRr&+;6kP3lO#n zKgIDoIV>EY0|!iKH?!6U-dI$^F?7wj{Sq+!o`3%={^z!}*d5PspxTv|<9c`a@hv-K z1oN88ExH>Amhw0Dzg&iTv$fLzjTVCDJhjgi9Az{_L#|D&6Zq%s{|@)Se`i#vZ6v!M zaiX^Fi@vTb1%2111C0$!?xsUi$b2!8zKqbbHSbQ^?JtJ1u%I(*PgR(yx#2SJl3R7n z-3mv-Q06jc?MKj(9NrDg2=eOBB}>rX=mGx&t(pG@t!VWiz<3x<@c+kB)q~VuS_7(N z7ooQJTZp-qN$XcwLoEhuy%&EEwwt*b=dQZChrHt39Jzn`xW{bsJK^xaxl&Qf;5}p0 z@*&7%ys28!FOPu38TeqtnKBf&uZ{=xXGWA%9Kh1@b)<7IS6yEsNiU!|o-O4kn6?b> zqm`oplV~tcHF%@syF{@pVoOD^T9|S#4 zq3z;FR`rU|xO`58sO=AMs&$xR;vRu9DCjUk@^CW-LiI|`ov+J<3^C|o>lE(+Hot#P zRv>85wBiqC+xEURNaGLB=rFqb{nt2!&|50!CeXeeuvwj?!?{g042RFbxN+vnZ* z{~O-u>uIs#tC{Vt13CP}@}#Y1TKIY3J(o%%tdU_plHA9--3qQ@(nk@hThmhg4hfQQ zdt^cWk^Om-94jYKNb158_Y!-b*-H-a;uV9{0qLLAC8W~=KPR*WVK$ouuu*>%4aiSw zx(R|z?y1Z7ESd^}_b%o`REsjRALK>I86p0~VAAtZo!vVW2Y63z@=t$A9USnrJH);U zo`RPk<@49t3&*?$sF~}S<@3kIq z31j$jhie&vKQ3(uJB%4~vqHGHHi8_v%^s4&K&tZi6u{#NUW}>8lx-|H5D*6E!J;gW z(i{*5iUv*%OxAOQsp5V^YjU$v*HCK%MJ>fN`5m9+V*A`&SXqH1_-m{)(^B&=D6Giz z@5}$pHMsN;FjOoK1TFrE%$Wj`Q}zdE`e=%L<-TC)gwdLUUv1d{shp~SXg?N2J+x)) z;V{I!!Fv8A(b=+nSWdT$kP*=|akf~}Z|>b%kb6KCMEkF>LU3Ta;-V?iC2m-vInVj^ zh%soaFTL|CLyRZ<2gWRATOdigAd!mP5Ox*z|;hpwmG}7!(V)eEnx-nP) zeVehPbj?s&_)%WY4RNpJ*Vng#GwIz@%GXLgpKwyah(;ZW93F=cz|emCHk`o5LT z`fcEP4HS9@xtHXZ1a$Owd?H@q=lFu%iZW4#t_<8(p==xo;b&Cp^6$NHnfoHp(dfXQ zRAvIfXdxOkxZ#f$*vSd*Y};l?!jjFh@z=k}(`(2GT1fsGAQ6T6F&8KhU3iFK5Kz#F z-*E{!1swynL3%)cf4c#SdDb6(-R&rx^;UEyAl8YD*NOMb<%tGWY zbSo(0iLfZb?-UD^i-NOVhl=OHSx^PkDgDF!1YZK2IE&MTZIV~sep|9xzc}5#iFUa6 zB1j*YeuLB))&DCdbwyltb{4-qh}YYgC6s*Q4svb0J>n_sEBFVcLCf|Mx0y>k1{Xu7@I zWs93j(Sg01u|b-q-D^OO*rw3k^iC~nfi!`%y!~0g1_A{{5`+*m00QK{8{NVh@inn~ zTfsFk)CdFDsc&m+61dplSZg&AdXBA1p;8;Waq%X&Amt)W2a@_}%c(U&HW+KS(BBI* zzH57Zm-tm`119E1DhFsYVnciCgF%5ILf}GkDlUE?uSdaSAaQ>8_8>o4*>N{zMdYMF z%xBP`u8C&lgJY#c#NIc@#rZ)TEQ0e;Oj0Myd+arh*;y|k_zPCC_nGvEsfe1@6yFO4 zJ#+Mm(b5F>BRL!DStZWSAie@B|ILLG7-ZFi!vDmNFbpa@K>U%SGw3(}fY&2$UlRQW z2P@f+j|gMy4!Swcj0nlXFhtAJS!2J5T{ubgoZuNVyXkxS*GkDD)$~$pmDJSMo1S7e zKHt!Duv)lbdcrnGA^yA53XT^HrY^@6CBdK6D(mne=faCh$n|816ZDwOFs!jUzo}&C z8$s)3M?lL`fDq~2MU(Hb+ltFud2?PWnDzS(^wS++^B?`l{Y*7M)#vD9p5e)%sJ~uE z=NOijX5CIoi4%%64sKODATN&Y%SSw>Xb8Bt@MX-N64kB@x2ZW`N<1RI6<`-74~ zaT2a}3ZOI>b^Mu_V$m|b9>sFI3;|bx65yO!qXss{2c?Tb!1Kf$1D@i#7;bVM_kR_V zC~iLFp119hn+az*KO5}t?D0(!+%MWcKZk-%j!GX(XN>h!qreITJZ>_0spKe-Za)^1 zLPL3!eL2c>H-M61bX~SChS;wSeuzG``&yvyKc_5#`c08~N+v)BqzFVFG`*Ej2f-0` z8?~G2KZc$RTLeZQlk?za)Tzx<)#{cp3PC&t0%YdTG&mhsB$Rj+EnlJkkjqg?Q`FHm z9jtel(vT#IfqhEAw}@C4*SaY1;ZTRw+Yxpk1CgyzL1W8P1 zI9 zAQrgS``JWN1DfPclZO_XW+8#i^pX^tE+XCwwG|bK!k-Hf z!|FY~6i3?SJ7X^V!MuG^5QFcOHGGSkrV4@E?Fo)6}k(irJ4-g>%mZ#VmdngX9&dOpG$YzpKGtL zTktb7gIv^`0WtP5A>sYmXrtsjL<~tE1Qrq%mJ(HwGJ9IjK>M$gfhy2iOX_>yd&w1Y zijVpyM+PUXe-bwMaYR4~9-XAq19K4ZkRmNFby4AbdRV3U<=IcQKhb6`P&QWvj!Ovg zoXT*wL{FY}N*;g=Q&Z8!#G+%DT;D1;Fk&*+f)6*U#{8obL9_zSh@og#(!F0NW#&&O zS5P+kzIlqH)!CXP!vR2$XC>Mn#)pQ!K~a4tuc{QNr^29l>VPyv?8Xh?0=X;q87jsT z?*{G0ZRjh;>lAzkFDmWZj+RKFB~!dh&NX$i!~LBBeg(61ThMX1W!Rm_7NVKl1g9T@45E-~1)(2ON@jVC>Q%x-CV-bP znl7XWX6NICjbF%P?52wStu#Zj4dD^6ODeml&?~q^L=lu8p)s;UD4WVw8Cfl6tmH1gozts^i7X!2Ee~aGT^$XgkRk(h#%UU7``NG z3r#bkm%t)RVM(?NB8mQgOuch(C2zC^noK4W+n(6AZQJI=cG9tJXJUI|+qP|cqRGqe z-gjTU>Z-5Sw@>#Ued?UvSZnWAs(IGKUvI$+8D99dE}0e9d&$s(SG+=QWWYKT37e{q zmut=k&y*@}PZJWI$-D)|1K|#TgS+zrE{e~A9cV>4D+#^B*>f-5n_@2w8#6>gDD`D7 zVC2A7-YH-N0cd7RY4ZG-$wdh{2ofvq85P_|W(4LLS@GaUcj6|3x6qj}_(_C)T^=ms zG^y6|izZ#R6|sgu4&LMLg{KfW`48Uh4UU)!v^MYq!I(K10<*S7oBO>ICfA03x+iGr zN`^=tTYSlk-gx4m(2JmQl@0Kf|4+t6pkf~kuzTaz?>4KtG~)e?>W!~qxU9LUZCN9T z?s|@NYAarWyMM|zA6{N*@AFz76qp)viALILFIdL%x{k>?Uuh4Pw7V3osiIFRD_omf z%;^0KZDYWX!P)LEXfOY1uzUF~VyLpM=j-`v(J%-mz7xxcIJYMfe`ssu$L2`McB?WI zF!pY8x!v6p-c|UKDb`de@|je^BpI75_5USBLRw?1byCvGGD1baPRhF*ajhVk%tq1( zjYFa|myocs62L}+qp-9l@&-4+jjlLIG0-m&zVz5i(>n1ghw`hK@iR)~<3UlHxV?L~ zad@ZGTcJ!)<&c2y5DwnxBcyW0-dKL49jCszSTf?>fgY}_j_xsv66p{dmkH}l(Z`h3@idVWRO=-BO zERCfR(yqRN>;>aX&z!6z55Y=&)FX9xVB_En3D$KHy@Ubm{|Jn}IEDWdMq#LklsnjP zI_zi_MovE~m>eErrdJPM+0YNZ^&d(IHU1N)p-lJ&eZL(;dE_&%IoR>=3#rB?H;YeD zYk|9%EM^8;+6;snhB#x8ulQwBK_;s##+afBS9)4$Wth*=nw~=0fL^H{T}2IE%rSj~3khvw5*e z26vc7UXL##*M8@vudlszt4J0^TSHIhKUr3hxc*o8J?J%VL9;(+fIIf;Cdx+XBKr&$ zDO4-}Lg`|5BS&cadN!l$6?1lK#G(V;CGtvRNDyl2=nfNrIimx8Ew)%jBO?8e5^kg( zxV_N+60?0#j)>-^y+O6+?*5W}EIYRUyf5hUpS)UC>|t4AB0G(-)_v)tT6y!!q#{{= z{ut=)-io}O1f4zl@nqH^1s7_nCz}m{_W6@c%*N-{_$R%!0lcA>ilSp(G)(cs(S4%~ zIK1HZZw){cM0o{@7d6N#8Pj~o0ap(;=cSaRAMhoh|F)b*L$EUE2t)(2sToh z42xD$kj}=39yTEk$`T2!Y#8E2@nVa!_Rbod*S?B9CP;!$6zi1L5D?h4TQ#P=>*JOr zp8@458gcFYj4^F6^6Bcx(&-qYa7UykXx;VJ+cQAWmhI0^7B>@6^=P+8#h>J>UOHTu zgs{4cp6~j4Z_n;k>{luf{l}K=i$2)Po`sc{v9m2)*l=30^aVq;?uQWV?E0iGP75}U zT0OUY4nPp{w)A`jJNdcRU{iNh-a9`I7p>$bZ{*sgr7M5Ugxz6#MZ05}ql**Z=JUu< zvjOPpZu3j9yXk-Zyk+38Tvc@`$~(3Nw)E7ymQS36<<$RY!7y1@x9c434uj$+i-SHh z^A|YHhvo9z%O|Jv+%x0y6fUWNY~DI4ck#t`v17Dtb#NbQ?N*b#dRa3c6zke?;;02Ux@Tai$;A~St=yl?xlXR&BYhjM3C{9y^1K= zaNV_PqUX$l+9Eor_fe8eo$q1N&P5rGw*(~;lM_%UT?rBkI;L8=`W-Q=J%k9mJxW={oL7M5OAiD=7ru#;Tiln&ZF%QV}R2 zpAR7fSjXS}gbLFP69=z7Fh}eLz=S2}KyF(whnvQcI>hi%uc1Z#s7lL{gv1!j*eyVT@u8{9R#%vDd70e0QfWT#q4FVB*YQm+g=}d9G<;) zIRY-st?4@PAbY!K+9^&g5`Dqif7LaKQCbU^n&?*u$<3P{J*;x;MhV3m5@(Da z|Ge)TB)pVs;X`?Bu^mY+@<$R58Z+UiIo_BO7HOEc0pla)xxVALO-*c=$h> zL=XkQSd7A}iBJeMB!g2~mjw1vaN{;I?;To~Was|9Z(-XRdGL{%MLu4bi`~g7|8p#W zwD!P3H$AUb6eO2#2WNx7w0ryyt%o8IaG73)gChQk_E?OXdkt|2u}v=@^LQIC<;xD_ z!G{0cjs8DP<98VfIoXt0r`8U>y)eKS0+Gg$y$CYFB~gevBH^)wr#=7E{L{ScBlF|< zh^`iGkT~7L&a}ESnnLE+?aEh2dFMY1_u@CWRY>CxZ99eOW3{xG+%ktM4$+CKH+Ee{O8@gP%Fk>6~DeXU&<6H+5p`tXH*~Uf%$T^nbNm z3*kPhXp_xB4Ss|rT2qDB;hSqmQgIH&^oH4n*}H1JT*ngxAue4brsH8QV)jn;hb)Ds z2xflF#-07&%xw6zJcIl+ir?oU=q6U|=pB*P8`b3U^4NM|RdcabH|4Wgom%4lC4duj zmz`Rzx)a0B9JK+bmYs&iH;n+Jg-d295ALubtr1|s_}i4Zr!j$gh}xXfCu`KZ!xIm+ zW-c{MecqwppqXA%x5rk$Yb=TXN28>H6^|y}=$H zg6Z6>u{2ke8F;;lS>Yd^L<*;VN^T6>@|*ZrK&NE7`@J*iu*S1^+Kks~Dn;oOa9gChp{r}DOG21yV-za|6Q=$BsL>AP>{&fy5_?zfV}?Ot6|O@p1^ILa3fpZ-b2XVl-<(4`!1bW8 zRay*O8{@Ije5)Ja4nQfxv1UnV(_4Wbk;u?Mi?iP|y3i(r;9O5_aTMQ-n=$&Ah9P^4 z@cN+sle!!I_jn`De#1$>YfNxe?cd?miF1A+kw4}(tE48Ow-ji89Qsm(97vhn|k}nmjBuNYjY}N?tT7k1^2vR~-j_}>OHR4N;;-NYz;AbW2 zE2hQta{WYJZ~FO>g}~esb{jLAOWY@1C(R`56l*D{nGme4p!M{-z-kO(^(On5LwA2G zdX`mhD>~@%v>QMYcKL!8u{flKiSM0H)q8v+J4$h{T%r2;kh(`0RKdP(yPxvwtA|UP z8uLlboSEub{Frmq$4PIk^GbP&W$TLqrjbX9>8pI@4MUo0TyZ3EFB4n7LJi4?EFBv$ z#60Gb(}cT)hpwDAZqptjN=hdjIpkY;=u4T(+%rgl&;w|aXN#@n^bZU60zni-du<5e zmEZsh>a-XRms_@e11|eY#&9r2E36!y4wb0MIv%m)fY2Pva@)phF%Cr4u&)@8q z+;V#l0|5GQmQPUKq>jSqQ;8yuzg1V@<)W&*EUBW|_}2Ku;Py;#$diR(Bi@{6o(Iw* zy7YwJ?G7hZJZwD_SpC)oC)p0QC zvjd6{Z}9TmODe=KN2YTjt^eac8ZL?1!SNo5uKGB3o?%>67hS7lWUTl2>NTX#km8VG z(qn-FTy}d8U+3Q7VY2a|Ir7e zv8(=aK&2Yyn^FHy-T<=-%OO>Rup#V54}R$fXsTj+cPy9Qs{Y7y^q4EZnIv-d=PP%f61H>HJYE!=Jeg zAawZAwrMR|v0@&iPbrC8@$}!N=3~>7ZwPkOF$L3Kh}c_LeBuY9xZ^}!TIn|((0$}~ zavIdb`i!JY6!R0+kf2$``DXLj$l z0(i_E99gX&mHmGoygQb|K4GvP*1?7BR0)4CZio=A#8)rX2=}+WS{;HqdIpo*NSd&e z3}F$8f#HokXXNAMvL(m}vEDSDj@ojwL+U3E5r>V%#AoE0jj?NE>YpUQFiZYFD<94p zB%^nRJED<0?ve~}SZijbs}6hD2(q$=3$=bn6KhblbK2KLr^tcGVDn%$h~Ccuayg@u zQ(ZQ|F4|s=2*p_VNMD5~bY$aW&<*0M9Y!1?ds2-0A?8>#wDi3o zmb)z_YfptRyd`8T*HJtlqrE3G9I5o{CKO}lq3|44lnDXVW~q5zy7B*?Zk5sRSSd?x z4`OhQ5oHEp59;J&7s8FB1&AqRPMDJ5B0i1!52S|wBm7?^!DTLt^B=x1a)}iQH6Y1G zITeoh@0{W7xX4202fl=Qs&o)pm^zFZ2VTrvG}HJXyhDb7AvYLTii0v zB9G5o6eX6auVv#|?ms1-aNSN(L#vxjq=&+W+$xSwoh-7Rra`QXHo`pGHovMZC-@=k zAufa=Y_r#gDlx-?cmO13{nm?K7|f%IkSHt=-GNJlizZN2ZrpXo%8hb9_wl(nsKQO& zj6a_cCAlCzyc<2CxoIMVgV(^em#T3rAb6A2r*&@mj(yNOxHZPGdeeJfkCsgVy+*)7 zKBuyTX)D9cWqvh_gFGj#wGLdDQF!XPZwGa9Cu#87KCmd<1Mt9E9+=2%yQRY-+%ljP zqt6r9Rj;A;ZGNj;w!)a%9x8I@AV$iE1V>X*dhmdOX-GDk|w?PmCcUzM;Q>P;$Rt|NAGUm@rJ~*ntiR6&?iLFaDs7WLLpuiZZ-Y`Q~TW`fNrGSw*G@?i5|5t8$EK*_&3E+#)pCG%B6NC*w~L2Oon zu|Qhf+|f?F$~UXPEKAAjS2bAR+t+ShH{$do(FwLO*w+%d(}l+UNij4UcpYX;gCGVY zb^>n2$U>qi2@H)RhF4Clgo&^}A4J3d6R4K`Mq1|Fh*l&%NPH?+`7lL99jN7K0Ngzy3bJw%4fi(`qhyX zYfNhycNrJdH_E#$)~mxh^j-_|Aj@0B=Qqz!avv>$C?~E{3I5n$9Vj4J7%}M;r?Y)f z-}%_ZEvsWea`V5*+>iCY+cMF9d|q_I*zHL*vAwHnY3IglJzKPq$Gt7hQe!dnasz%? zbfZ@}%n`WuVQx{AjAW+|C-2WSV{91fsz0p3hJ3{uP>i^LxvMRfyLc>V>C;b-71b2Y zDSVVu6iJi!IJ$wD|2Brp$^J^Y1S+Fgl= zzqTmfWYeEo5G~eFEi5be%le~%mAR&h5wIvcIqdRGF;1fQx<|~0TQP=$KmuxgW<QoXHDQS2HUUqA!$3yT-p%9o;a4d2WE76Qz-L8x2(9E{% z<~^b`v7Eqa1uKfTz65IM<*k9|WT*dx79*rA)96wk^4eGw}S*aBb-Pb+I*pQv0(I(UR)uKlOP+ypx~$P z6qR|XRe26X0gqCep#}U?ctJpf;``1Jqrv?^=Og@46PVtF>5$3an$Gp?L0uFc3KrYGjU3O)O)Qa)$SKH|5I>Y zOgkIj;KO=b-&|X!z-E|R3w0o`R8pzRPmPl%`%kF%+J44a)L1}hV8beRX3c)~B<;N} znoIH;97nzzSAO6KVW-Pq1B8VgKFc=>Mg0#DbwFO{qpdoM9ab@TRSyz)C9CG=O}99) zYXUO)F9nDAibkuQb9=T#D#tf7n;o70j%*uC@l8Ce`7|OlvE(yXJ+{Cb(R#Qx zTv@^WjL*I7TVwhUg-!>j!gBhRC8+bl{}qf_-^H9Nbr@&-_)T*^&uwq7aBc7u{9730 z5fOBuV`Y(%T+&T7u%pK}dY)+{78htAdj%kS_d5%D5Yt1sOe*?YoUBy5;`>Rg(M7Ob zu?i zL$8f*gJ$e_rGcUdeinXhq8PMt#)R>cR|ccsneo4+PC4JQb9@>=YA2JlN-7nbdWkwZ zW;+WwHAz1$4 zWBgcNdqyO(QYE#5o|D`rgjXqBkH7t3brWEHo+JH!Ioe=Jniu>xkqZr&Uzi@>Z73uf zpVYx8ZgoN3tH&PUBjfC*G>qZCEH*s3%m-bL52O-lJ=Sa2p4*w-xVzg~DQO?rNU3#T zJ6-bC%mV!}8FQXO_>i(6;tF~;5zr{KH6urpp#)8nvDkq@7H{T)ql0b#tEUJwmFyfJ zyM@Kxv$u$o3Q7nw+JXik&n>GbfgdS+bQd2u?lrH|fOtbhd3gzvKh^*6JwU@#f@Ia<>w;rNzk&rY*wP8I( zLgG2|JZZD>5dXU!3t@}kg^|O8`pT$ra3%wz@bEIu2S~Haa9*Emem|WSGnzTP1zlzT zC24%y%U+=c@T1@G5|fn!9RFtd<{oD;$h+w#^_!O?CR9#9awxv5hjnSkrkGW5gt&2q zsHg4X@_jh1WdAsHC8N^`Mb8?d%o$RlM|6n+!}_qRh8eg^3y@{F zk$Vfy`WFLM#5=*!Pm#!39aeD=-As`9Q>F}3*G1+NpjEJSHN39r9ooukdx`=%@x`U5 z_?kqA=QG24nMIM75#gK0NVyCqJnWAgI*AGbFFxjP?7^XAUuZ%skg<+F&PWZ$z~Q;P zhX)(O=l+BfSde!>D)r}Vc>tn}>Z(eE z6n?ZAc%pE#;*^f_B&g!QBkJ~b_*>IvPiI(KMn9(04DJXW3+EX{|9RxCG}LmYMEZL8pT@~318^i8P2 znm^P2I}7~(dq-$&M~&}Fz2`V0oN&~H5W zm7aTi8qF^0Cttwxd5k;h+_Z)CFVwMIUtc>5(oS%#YSxmtuDr%egvz^s1zD^7poJL* z_f2gxKA!sG0HG~|nf*J?z*gfD&)jp>ey7Bhf)0W8An>9(phrIh5 ztAyNUs~|Q#XZ~C2^MN?Vdl(v6=kw8ss-SfJw3py?eTb8#c{LzkeVT6UD>71+E+G*!6B1IAxGpCUu8DYo^BO zNoT^~fXra}@!b7xt_ZtE#Fi?TR<=v z1U5}pC1#hwu3s=1I=lwQsnD|*n@n(apG*;-V=8r4F zqR=FKB~OXdYy}pRS33UBLpJmXAF+nep0<7cNMwUCDDo#7Jqi)b=+Zc3b%BF6NEAxm z!iTsyZUL#9=e*VaS!5aGTa42XlAvonyZOpchc?YoHvMdC0JwB zB0jN;Un$CHL=%oSl3wK16;5*AKma8Rv4yX8K2h)qqtw>59cK^8u!CSXgXldf(!ZyOsp;+9_>0ix)4#zzX ztdvT8q|A&S_h}f6Y@ToHfyuj97zIler-(>5qG5AiS&-~@TnEo0zX|DDM&OlY%#Z5& z@(`m#-M0=ZLG2`!ffHkoKj&vIS0FAiqXXMphUXViI7SI()p)FRN4GVYi$%NcaFEGOYsLa@Y#!@hQ*1@3jcuWWN2A>L#6V0=2A}Zw z7k*1SK@&G52)QW8ikn3c-KZy^+!Cpm@(^BPJU^JW+WYR)zyUP3{~o1;utME-?GflJihO>^85H87tt9g zhd`pl3lQjuCjEGv=I4?rBW)-+IIqa5r&!b=LIpk0<<3Pl{m`XEnV!;@5m8p`*jYLT zK^(1@Ge{O)eJePQbQyBO8z(A=4z7u6GFu7pB8V=!734!Q{D2!Y8%EaLb0^$Q7$=Ib zO8mn_@c~DuJFmle6GRx*1pNVr%X6I-@mXMl8)#J~A!juFvSj6eh!FTEZ~=FK0GqjnQ-P7)_q8plMM;MVkTcX|nV6x3ZB=xJ9uEMd zL`oQ(q1WF$VET|C#Wk6rBSkobN@|Jm%TG{4=8lLNyN&odx8OkiPG&;%>!Ng}Ry~!`Au<2^Y#Dw3m*^SGEZt1|KS)hBeZ+*0 z+ee2MEfNa)J(zzxjrB*B-n$Zgf7kvzhcZM(|2Z7< zzgvSgh2(md1Ri_mWE1xyw{qFZy8~I<@Iqg0TDWVY0_vw9lmFJDxyN~4g8%eI&C~1* z{vnH~S`)sT`uC*$y|73^;@q*B^kLAK753t8DfN>k2aiore9b%I`zoOKSxvfBC`cW3 zai?Y&Hz_$nVx}>*J^}X)FKOpWYNp>NkthiJzhlC_VicHAJx3YZxf(J6;h+%GpoO4V z_z6>8j#-=sht_$8Tc7VV(igto>uX4a+36q3rqkxr;w&v3-zH(7zPnOYHd5hERUbOC zG&M8<&Ah@GW|i#@=vWm&>#5~^uH4%22NoM;yn1lr@>Y&Gq8Rpn`=f&%{qjA;E$c!O zk@HEC`L&ex$vi=q+q}5QGS;zKP2gVywjbZOB}bCV1Y!|i&oSV093V`Beww`;89j%he^!P4|IDFRB5e? z7FCI`LPGnoWTZZ|{NsnBH%F0ryUdc9B)mF*O)CL65@vS{|wT#i@`I6P)4JYxE>3Z`~P}^rjx4tPI4E^p&YA% zx}gkrhqEBA`!poVd-GIeM|gv1!4ZSP{(4f*yy&Se4*XX1Kgo(l6h^WtLqXD(GQSO{ zg$W2S=|~e)imZw%a@D_B3NEK;JipuGpvB=D5e-0!!S!-;#9({k(+~CT`dwIjzO3{6 zgX90oVokV;{Es2R2 z;IAgiqW4!q5d|v?55tX-TUoSLV1jhp6Fg zP#s|x56ELxxX3nR4Giw+)}r@neYZlY9IQMssYTy)zdUjuqya}3Beskrfj_9L;DeBD z^-1NurVnaAfe^}YfH>&iJ8$72e_7p|p#QW(Syyht3Z zG%e;zWRwJz%c%r+LFCIcP@y5njMIYl70b_m1{{O04ORb%78z{DfQqm?&!}df+|@oz ztUfdlU~$K|RTvOPLJ;M7aHhc>5Ed*J;XzH-ES=!OB0#^Lk-b&0Oo4F*ny_59kYF}l zXL#t4h$vj-bXSDfY1>=y$*B!;#n&?9o^&fE7v*Oh!N6JNepY0QH@ z1rHD(rQnnZp;Gxk?1}#SS%Tgp8b*&4Nop1*--@TJzePbZ;HKK=rLhAc#pEsBlwpw`Mop>V~ZrqX;(e7}(2en&h zZQZEW_4OtGPet2_TkOu51H~n|?^*{+F6m(7Nu(8CZs`Yl{iu$|k)sDeU7JbYiwGyI z&XWk{_wPm%5t!+RJ;I-he}Y?{DU+`1cCr`qSafgbfO_YVIYQ}B8eKIx4U^NJ9Kq}1 zO3dywp>WEikvTjA=pyqJ1X`Pj{6^g*B@hm|PA3LOEbaibcVYjP&}-MLZ(5l)%)%@q zc*9;|LG0i>!>^J1*{9`q)iGynLi;uXO(#LOX{@to$rjmPf#%f;!k>ker#L8()M3gC z#`9MZz&HrJv7P!bkT!Ol((FZZnK^re8<@@dH>{wv-artz;t*w+U~gSP(1=058D>pq zIpbO>xNobm8n=XVYIHxe(E*CfiL?4F^PYEh4v_9lS6`tGrB9B6di#WRZJaHh7&&`A zJ)XV34-seSW^Y={b0ku6Y3gS%7LU^;mBViUBE{J0mL}!#WmB)90iH@(qow4c#n_L9 zGtz`OE*bAV!2&(UR+6|&pGZxz^N;V0 zhJ2@{^`^uzmdBPWB4M1sUr{L97p7GP z5C;7?5D3wOG!Tsh!@xgcG~&2p55K%9zmt;rgC>u%{8yeEnziyd_Bev2Li^hiwC*>U z3hl$ueA)cxnJVLuf%nDIDt{0jw~$B)Z{B| zNPWrF$?%1&c7{nJ!c}Nh>r|&{FaRRz?*0I1V+_TJ}vkqsqV&hGeL*>X7M(Bv7IwH+52V=)i$66di_M9EgZ|#h-EQajG?OcZJ zeYO*&(34Q~yNJm+>;-d|H%IRQcgVKJx5$<;`u7&Uz6+Zj!w-QOko#qWxPDuKDlv|f zFS)+E*B6N;EDmhIy7&&LSQi@Y`e*xH;fb4&^H62zveOQ;xP1~LqPjvdGw%wUBXB%< zNkMuPvRE&Rz-19NSt0Fd_<30?{CtBS-a(+!*$^TM2_O$ntadeZ0lFgUh@_@T-LiGOks2 z*U1gtG=TtG&O;U%IBU_R0gro|r;NNqC` z2!72X<0-uRnoEWUgY5FX^j4S(A(3EC7P24)q^yH@2?>&m^EvGY*N;Hk?3sO|5xMiz z`R8gb%*WdF9!K;X9uk9uU_gY^63yD|MVbGdu)cSKZoxg$^G@_ zVfVCue)`q$n>@iWvqXE^Z3{g$LJl9#2eIdCj${|h?C#!m&#I~4@Ttst!*F;DcLk@t z;8o1mtxkPdo=!a$TSi?jKWK7uVkLDj=fJ7rbYJ;{tIF_{IAwPXo^EWJrKjxmY4t?& z>w>gTdV&MB+#qjfds?#>;Y_mKjCuuMlZ}N+7^Ita_Tgd2st9Dnp*`$ssok*L5C!1H zNZBmaUZuD7He*7T&Dr(oLzmU{fYaG%X*8eKuciaO_KvL?{fv{+=@6CV^#sO+W8xp| zNiUF0Vk4M@#z9evOI3U(Q3evkUl@r=jQnJ|0GJ#nYu>7x+?~3vjY1Er+x)w%^y(}> z>_R0GXVb`}KQ5_+@q>A2t5g*xz!)ho*}?cH#&UDBIq~DUy+$#ujrd{B*y=cIxc^3$ zZr6s+RtHaNzVS~y46`G5+D~2)Uc^U%1u(_fN&ox3uwZN~dSM{~ z*eAkGbI9X=j<70E=|kcK(8U(0Bt-l5tw|MDK-YHB!K=aXNGZT=WNN2ylKm;lvFx-G zvF_dZu@5T3fw(IW1cn4J!okpW%rb2jb=~_HU*%hF)^eP(JfRtBt%(K8PyZkK>(xXE z3{!DAj1FZyu`1=HhVC1R+cc;Y*a;;U0KFSn+0!9^M5^Ik$;f`H>f5JW?H|ueTSKX( zB>`WgVr5+?mynyhxUcttElgOLi>71-3pTAdOf@zxs6bx*!NnGzTq1P-;fZt%?}HmE zH}SxqKCUz|kj!N_iYBA(3dXk<|XIrLnG!x1AkROWohsZj;%I(6m1HjW( zwH9R`HgV88gAJLWi%&&#zWCr;Zng^6HHZ+6_l~J>e_OcU_NsC65<%JI&}`l=HN05i zb~)mWTVT<97q)IsbHdPOzt?_#wf~bG`S%YR_Shn-?px7Q@gJpWf@8QXa6|AQG(

    5Sq-}mjM+br!5^++0LL(9Z&acNaQ>)F6eMkq8qCo|!XL8dXG83$};&Cy4K_7Vm4 z3%HCAA}Rq~in6^`HGccwKebb!5rTE_F|lFKG{~hOxvM4NP!L}(liVp5Vu0S1XsmQ& zzv1-;4%0gGLVW2_<9N*zP`SsZ&- z_(;@A3~p$8?CgsOTF8>P1pX}!o)$!PShvA#Om6UnK-t_ZVvAL3VE52b?p0>V0~&GQeH^ zLlPU{lq#_!Wb^F8!uombM9$ zT#tiC>+pYjWPG_&4W<#oBOjC7T<00N)0p)2@bi{GeF+iZ>Gnrhe%-#w*qv0JtDIU*wVw;l5D5$S4FRzLCE__nnkN2qbb0Ec_0_>BPPw80>0Z zCO+*T4yeB|s&uj?F{4)sh>YJ2LOIA$1YK*DGhgug1c+~V_KV5ht*VPX?A}Bm+?#nBg(A`uj6z9*IglSV10L#IAj-mCi>pqMh#t15TW~cw zrHxEvTo&t0ge+apkM9eCW&T|Kvt90-4)(pI#$bitQ)Q7w7g9y$iTsit4gXwCCo*&F z)oTY*i2C6)y)~}I&q!NpmZJU@sdoQ;=l-ho$`dQG1E$n>0iPa-m;weM{-EDODoY&@ zF%fNqQ_CwgG%)-B5c)5wx+H5jjH0Nu;y1v4>t_pB_?G{bo=0*?nFzRz`u*rJF5xRN z;Y}GV%^liCNFZ79sYDA9ysh0J% z2j}FYJ&j#@gd=bJ*5xaIScd7~Bv+5AET&;Jxa^lqoiSK`-PTEjr5!L4Yt!Y#An8EFpwtTjT- z1Lqybjro6AdZgjpfPS2KJ7OC2k4EcSDBPi|0YIVySKEluD6@$?p4K` z&HHgoA08dueQzI)oLyg3Da-n6%+I17-@L1%s*_V&I^oa10*b0>JTCldUocZJ3LJq| zkg*^2zNmTEgmP{&Z9=OcWV+eE8~p42f#}O;+GLJ?YwgWHxWfMs65+c=8GDy5Uz&rH zP<-t(iMaSlA^C3H6&J;YBF9WI^H2@jKTP?+W|BZjnR2Htb7WKANJga|#hLI~_d8?) zz*3mr$Y?*^<2Ej~C}emhLfZ=jze*Ic;D1BGb46eS3p$MM)e4S#AeOm54QJl&0UcKK zhUWcJZ!eFxcgK&%myU<`M4b3;`&F)7x9>5X;ib8%;nSSRjHQM_A83hkpwN?9jtD zJWy#9-b?k;z=E&F`57h(h7co6%n36vi^L|M%#YnJZ+{-}n`)vyJ11ZQ=`9?4oB zRRuMsc9CPi^nsB{129H)?$R1)b?SrA{Z%Pqe{WGV2o6!F5#>00e=o2`r1gT5S^9(^bEu6TznR@h_3O*+`U%l>3BlY944OH4&P@0h2ptix?roww}c(n5r-{3H|g=@S>yk6c^>fG?OW>$NRtmvw#E`J-NgM z4@CW<>eKH*(fHE3mQRDWKX6lp==d1I<>gFDrby^;AHB|ZuA#~vL&~ET;HWwYp;?g} zCcW4sKKs$Xr0u!cd-x$$Zc1&t!S8< z+@&z7fP9pxiK&9U=!7#(aqSy(Z&&2-v`Z3l*kx|fMw?twXPevzX*e4r&J7*d+76Pf#Nb_QiU7oD%j` za(#_d`N4ACj8zXe(Usa~idgVzr?(T%&&bBVfS~9Hw5bw<0&eNEe~fEFb_ux|@>9wN zT)ljuKJah2Pn;L`^Yu3|ajz@SoLe4@T;+K@=VuDDkLISB`SWfAO$xsvRP$CVAs62| z@pfj>Pw_rjDtGbRz{p=xg#n@3A#*`PimwVW!{+vA7MKRh5Ous-OVRjiBaL*0{VpRB zP-UOn`)H+^qQ)3FFJf{G8(&o|Xo7{h3NCDdfrX^`XRw$01bT|>IMw;k2}O^I#M1*A z*@s<|&E!~cst(*^Fm7p4vQ(z&&o^}^5*oKG69t`=PfMzA`%j+h#rzf}av!U;(<9C# z6~r#3*A=8X+e#spCW>m^)GDG2CZ;KpK+ac_2n3TvtI_<_oYG-!`NQD$6?sBgJyrk(y zT`RH^&F0{kE|@VEA=f7MVGyh%*|@Ymb}qVD(+t&ASQtH_q{|4eLmu{aeD>HdrmU}| zn~H*jxt=A0f-tcaItPM+R?IW?)wVi<+;;HyEcW8?H zr^%6w$m<<&6e36$)#c7l{girk{VDrTJb=}hD3d;j`}b7Wdu}ef`e&-1??P1k3*(!k zd~H5|>ePw)DCXIH{F&Zg*QY9-E~?Zn&StZkh@zO2is0M(%g5);%=K-+?$eI1apjxc z*0;y)=M;0c!ua$_L18#}b+*RNUbC&ERM&GKJvox&%6 zR#lgqOQ++cHue7>p1uJ%vL!j4{}#f3A_F;g47;eyBK}tjPb={T95fnlo*N5#b!ML5uP_&u^X2*nU#n_Kh0lvX zt56(lxQ;x)wi-)B6P|OY*g5PJkn`$qdz%HGB}xSim*IwuXV(U+_Jo@J=^AZkfogDS z&+(`JB;$11nxT>f5QGXwT@aOPua}4Y7;okqi2?=N>&A_Ob{_2&(6^iQLqk%U)J4SH zv)9PUGDjTx{Nu!nvXPU0)T4YWO&Gye_ys3ZEr3_>cr2USS%KC%+JnZe3MgkkH4ZSjT@SM_H`N(&?mR1S+#u2wfwN#zeyj)}(nW%^?($@;O}k7mSiv8!&(V zn}9CcID@x~@#F4XNQ|#T{*=I?zfv9A4_C8vpGdf`?t5Sh6Ef4E4ZZtddEXI-4BtU6 z>3MSIde8d<7^tY`wWk@9Mow?o!GAk{3?paBdBzGe@Qg#+LkhxLS@qd};aJOJg^TnM z+6&rmBj8hoUcbtq%{TSy#8$QlDRWA>t?h41kgk&es3FjC!-U;U-YsD8LEF z>AWNxKyAw4a{4DCFcJrgT~&nI)bVu0U6~vwDzWQFV}KZI!kEBkJzruQ&gfl>j)ONw z6Rx}R1x{?>49>M0D;~MjOsIa`(6+jTUCjx$n~siRsiTlpB_}mDWGRiXk5^-w5CuIW zytnZZ6*u){>}l&0W^}|W3Pt#BkPLZ=c(>ss|t;E8amfdel`zC zPk7K3r1HQ;Cb+@xj;B8BmpDCIT5(2B)f7r0RbFOz_IT zt;xlZPV+^G*zS3>zy2e3r{W6-_HxH^&U}A6TmqrTsc#IPAjX5KY@C^FOLI*#IO#P} z+WpD;g8Jd=3v`*?{_ql!yf=sfkIzl74N zZUjSgoKD;+#`56c!Fo(CpmN4VdrDJ0*%|^Zfe8$^5}192=2=C}p;(ly&@vT*!aaO91@5z#Tap*;<%SZahB=?h)$Nw+jmur87+@Th; z@w$b9@6S(3O-8fDIYZrLK(@58~AYw|6hj0ae7r4k2P8LZj+Y^c$$#NI+xMft$!@*GBU|?++=Sm z^`Yz7)*pP=4CQ?YUu<3+`V&4@h&n53`SqS^9qhr(!ixehEP7z)lYe=3 zf362!vr%`JB93%qr{cu#Ph8B?*=SfKnEyg5Ya!8kqj_mAXm=kexX6+kcfCbuYY0A^ zQe-d*^IZYGGcQS@5Q{rE=BZDXjUi=r-|k$_OEy_Su4J;CCw#8~K+eHmoWx23$WHWA4XdyBKbkUsc}W#9an2ydN~(oqO>ZUag!}ymP^d zUacf2;d@UXn!e>d*&?~oc~9pwJ_CI?u{%(@ez}lJ-scEd-C!0xRUTRB$a-Qerg4@NhGw}is#S@N&Gtouz!7oOm zQ3x%S3`35EqZjcrbsciSFWj@jZJ%&)vj_b8CU|A#)#c%vJEhV%-Y;gUx8Sa z$c*{A$KpPP%8N1_^4k~52KQfx-ZS~wjQ=%uq#3XU*cVptHQHU4OK`~U+_Tu`&^qoX zz}RNshGn8kG~W{IoE7_hfrOCmeZhthGU10MDz~JN?mh-E{*mNTD<-ZHei3_hHIJO} zHv3o_ka<>D7Sr8uEbT+rPp>YuS`l5vJIfotb1W&f8e%e45v@&VB}eIyqmMKV=UOPB z(3VGT$J9*BJA0^Hl23ji6OBx0WSEY9?9J`e~4lwZskOSmwXkrnXarh|FoE zW){6K6!1dLr)FGr%%!&DtqhlcDr8KN`|h=o(3V;YE4vpon%_;|sos@I z_h$yn(IGd!sY@{4vqZV|#W(`ryyzs&%sB?B->VXc>OG59N&Vld$o$W$JQN;WBop2P z+Cu)j_y0WLyLq#=Xs6!Y|3;N#RpmL>dCyj-5S=>~GQ%O)pU>t|+vWMpk`;vIG)90> zW}j=n4*4=v+}N8<0f5P=J?sgLYc?LObMlF#V(x!7U8Llqvqe2QB$ZYv&){P(fXP@d ziuZ*QN~`E6Un<^0dBaEk?%;2F>*a%HJDII8KB<=iGD4h=3L8WBAY2(-%5|G1 z{e>*=JMjKp{MlTX;8iWF?ZMxCu$n*YF31sacN2_uYjnS82m*f` zFR$+3@aHRrj|Hcp=|VcrAQQ!4Qc=+7EVwK@1s za7^3C#B|Dn88ejV-|`zb(H_kX=BN+(e@P2p$QAV2;4`s5V5rqtZ%dNs9V$&3-;$rV{{qy zj~L-)L96MK43ltO7%tYv!2fD%B+!kmx_GP_BiRV9DEW6xDBLiPN~IL}3EbAK@NL2dv!3NNXIUw1`*H}7~)zTgqv>78G* zvb1bYi3|jWTJ9fHKY`o~GNlC!E1Q`5nn$W8*-)Bc63w-oaTkwM@f>8rZkKDo1%%>k+72&iCCh$I#Ptsy#%ov2P`=jr$&8=o14g)l1T8bzTgyF33xlGQ zXW{kyZf91rYNY?U;&}H@$!c`XK*^WVUa{Cr$6xgu@EG;0IAWhY~xvEo*wX{cSXjTaQ>~CTVE-e%WO$kxKhF4><#yQUr zJfOMO5erw$#OHt$`wAv?MFECN3K)X?B{Sf$DvHTMuMT0-`W4L52*ATly zNuzB8`|F%|lmLL#J;!aEe>Zr%Lclad-ViyMbWG;49?Z^b2Y7fUXC ze{nWLd87kLTlkdX@656@HkyaV zl(7F?MgR!}b^;*@=z2Z0*;uKU53@UaQI8+~o0!#HKvAi%48reT2Ck?E%D41Asiw$A zkb8HAAMYe4LAe-SElcLGUKWZu?L@TG*B9&uUMMXo1PE8F5d_ym6Phq|s7SUY^g_}c z{YlBIUEM$`t?h9ldy!_DtR#V}bSLUFDe)OafX5QdddjiBdx%5KHhPL~g~ffPn3 z)-&WsH8027sHq5-m9m2Y72jSm*lA7EQsO9G(_# zNq*L?Gc+0DhkX(3<~I>7{3f7;DE{+4{&nS=GTw?R-sK^jEVCn~=y)nnH-mJh=e0Tn zFdJFn^SCFg4s01Vkqjk~5&x^&6V=7zZ;X?|n+I@i8AJ;<~v9g8^GsNCH9 zwuoU|1pc;Lzr1|VuL0b4tZG>TgLvy9(gv}2L?5mRvzS&^{rA1{BcI9kH>X=kqB*k$ zQ_yXGqwmF0cO+*V&U+=?(RHN0sH)jg4xqs4KNdEFklFB6I~rmE5|z|Ah92p~90T!j zwNmMA*cGE^quJ_qW*PxCjIw(kzp791yi8dI$hz!{CDtzd30@dsSEeuIKnrVy-}fXQ z7eUjrd*BtAMt8;{zr|Iv^YU~R<%+1WIae1JuX6L1TpPb){rVRE>2w;AVB8d+BE1I< zTQM15{^OXcgJC(~SwDLylGkIfe7(v}-NDMnG6>j7u3m3;nOh}l`M z!Le>BBNQhVNz3!sq>H&01xM&5;lW1s(6?&Iq~?KW2z|Ig+AEZOm>jeg78ztjC7CS}PiJgX`{_#Rw_hC<&Qy}(4)czdoP<=WVyxr)Vm?rvMgs^uaI`qja?)C zTWz&&7eKpATVE{mSGtl6G$^djOVwU&@F)0;{b&G%w7tKrvo|0p!rfsCXCz)fguQ&s;`cPWiAmzO* z!O!BQrkISyKF$I^U$jIqRy2-on?CYXn()*|8gR<}WeVIxq%W#X@nJ~8kiBG4$Wu7+-uG9&2@-22-4M+i>Ye?!nN ztX|hznwP&cIT#=GLbZvH4r-sjBQFyr*NPLDKbLj+@okMbiBX?RqJE=2wWMo>}M>GALakr>9cko z^fc~jKt!*uq~-2b!@x|`_E4{H2EpQ+`QS2ugcAB&cfXYOZR0r?JY&=z-H-sADtODz z4#PXXeDTwWcnIaPnRpKpF?OZzrv3sY0XLB$sFH53y$;`$-&;NJOSXdPG>b=HXPHJh z3(Vv$#{>zd$7_HOKc{Gqp@bG;w}9kKhVYc>E&qahts_VQg2*Hl0I!gYVyiai{q%w$ z$L3_-UUS0qbN+|xSLBxhuS`t0fFVSvpNq=F$ei9aLY&{!>;4carG(&Kr00nM!2H(H zd^sntAO#n6;-OEMV))b;nz6rS2Ks7D?rt{-rn)$oa-$u_k4O)Wy)dko;`|nT^%gOZQ%hTnEJ`E0AD|Kd)VH{z+q}7CrdB(A{-mLQq-nD_s#}`2YGX{4&6XZ~ zp_MO0+R**I&V(|W!Ky9|8mAFW-m{&(7tO4>z?T@Nr(aC1dDBjvn zVI#^wPnYifLUK4JaWl)0dt5T| zB5temA}Y?_!^!$7!*}=qD~J*piY>AYJ_~H>**wGXes{;2m~*l3s1%BsvYZPP4=0i` z)Mh}KqO{!t4pSV`1orUL+>uylz)yju8piCQRTwN()4)Q_THHF>)_4oIGUc;=qwU|T z0a50zE;H(+{4x`QDhHi)x<@TQc=aTUI z0uLItq$a}!8;X{o>j`3ygg~H9CZ2#nFyD5L`&fJI^kvQh;#X!ie@k}c0vAoDU2qgl zH;zFtke!D9R%|X;Z7Yz+0k3et2G7+c@k>^K9g$ZDH{S{ckO6hjZUrpHfhXtu&7l!n zERsF}LXs3-EVAN&M`5OHgw5m`RV+fy!2dl$B=5U#0$PO?a6yOXD-Y)TC)&0=E8wWZ z_x*wrql-nZgMjQX3g1sXZj_!Fr0?60eV}wm0s55KpVV5R7FZN|P1FFT?qEY^YI<*8 z{NLUHTVJ0CJr;MP;&p;wMqBT&Aou+D{25So3L9~A?3N;sshH74re-W_KT@se-q%Kp`;}vkfFKlAt`;k^r-yv>#Jx4EhM;8^#m^tQw3#wm^Tgtx%MP z;erPFu4?){9p#V-A6)EhLIHfyj%)kv351Cqs`GRgn^M`l)hD2vl06Zcjt#-CXQmrK zfttAUf50A13ejgF3q@2s`G5Zx=)qGmDWQ+qE*e^8iu?2dsmst<&qot%-ehOf&}Ymy z(I3+1-v0^#wI)Lh$Fi)b=g+ciTuV4>EY?WgN4gRVZ)oVoAAY==Hf4t*RL2)p^z(o&3jq2q zVMX-?lh}Z!!vucZy&AP8uJp*{M@9ToTkSF8gJk)k$9nEo_4t4Ifp5z5`rIP6=-u?u z|5HL+Mt)VLKgc(2E&wf%42+EMnO4&UxU!@X`y2t!ni^p>8LX+_)qGujTLUu;jY>Ds zPsN)^o33&S-30nY@m`j48Ma8Z?n6rtnwGj>IfjYfHM6u#tp zW$FEq)ojGwWt?*c#v8ntT78I9dQ=Ctau`h>5=WNridyd8p0akkKtUJ%_67PTWupS*9Z9C(7<9=ElE{iD?I z*5;*JuH3#%ym9DSjm`V?`z4toRkElkX#iYqP8cdgQyvdblz%Rp^8#dX} zmv#z-8}JM&ku=@8cw0a2#ED0@69;SDcW=eN`YBiL*1jtQWm*F${9*EOfjEguPSo~E zRpG2KVTHV5JH5v+_{V1BTkp(BpqPb=H_+`#HMf%ZV`B9AqvaOvso3!QyBDUD2O#@L zp<52BRo^Jj#>xPw4UH}Fh0SN}-21@iwd805L|gT2&!i0>5cMs7+=R`!Vh-btowJqG z?33olJT|d0Pc1|4?}!rKhMvkU4-addxcHP#T)TVgxWN?jiVKF~)?3=jWL{0q(#Od$ zfWyx#>`3^*`s~y(c4J$GEF#_=X8>D%OInke-zblhWozpi+ObW70W!M0eiR)>gz3f@ z=T4KQy!kD^d0YdKr07^lm};h5+E##kxIMVItnNjI1&!typcnlBExQu7 z!O^OvD8sC7dWB0VR1VE8N9ebQz|7w)BOb|RVmPSp4;5cuz)nT~={Mg8;OwZ8g*GRp z3xvX^E{iP6ftru6Zu`-tb}pRu({SBH#r5D56kblpm_(PQtCWv0x z5^yCWG(erVhS~jfh*_0*_Dcvi76Ep5-vDR;TkB=qG9PK>2iJbtWQcV?xCl$Kg{J5H z^oA~@GNQ56iIFjD&_T%ySRdoy0X}m>)ZLYT-5rk6y6eIPXdp=tIm^NiVm>Rm3O!Re zg2E2W@hzG)K!n)aG(gys1Ztxl`%T%p!IR#1KfUf^Irl0?P>07A#Zb#CP^P;$)0Gyi z(q#2t!g(<6lu@DG67e7ptg2PHUx5RJd;$nBGm@c)!+2klsQD}bELke!Mr@my2KXAI za^}+hq%@HtO;X=Z?){@c+t5|?50TQx!D=PEhu$wo>0wkExgY#xArs_fANw-9ARQ!6 zg2Hkyqu{#F$*`^`2;;oX!$oI?7nxQ(XH@E4q7(kQNB=31ZEvniDbU%5(mlpy!}_PI zW`cQO$E8f~F&qHqCMZTJu*TbQOc42O*BOu0F9tZDUk`6f0`e1o=zhumGUXng4lbRMuKf*~S>Dqf1{p#|`sx;B6De;@4S{ZxFW*mrn}T zK9Pu6mRb&!$43z!hFG<^Ab@DU?Yf!mFM2H|hu)kpOiYGgsVA(1BIF`9EzC><(6Mv3Y z&j6^&WtRC~!!~K0ySJ-OJFNeR;;XxDk?PJz*qTVgw!;bJw;Q5ZI#cBkriZ$fS@d1V zl0T#f+&TV$DN;+(W6b#HINxJ*wk`}NLjlyPf)%KKUPg}<6Ez2Q2bJ|v<+trPjWN4| z$@6JEsC%2ow4#b<>97fR1cUnt7Mc9ZjUAvWwUgA+MBb`_YQs^7RWAbS_br2>st`2j z6a?=%@|e{L(P3y8*bxDu1i*zC`KEK4j=w0-8M^_keIEfU$iwuwpCP9LKUF?7m(g=P zn8mNjeYHxnC|b2#%`wbxxFAcQyO^gy2IjbpT39`?ju@sFNojRq$P-t!!d+x@Tmi>V zaDGWOZ-b}3q$<4ZzIlX>L8GuBIuyyFcDiHQZhO*`=XhoRuTYG;yoL95#AZ8CiW7IRn9aF_zryhBrnYkGos zGLSCaE5GLymgIAA9b*`_UIC!L<>ij1@|hIwUsky zrk^s#HK%tgl2@&(1ozz4POt}zGC%WXmig+Gv92RNs9pXMsK!6LSlh+PdQK4CC?y4( z3{%QV!xoan+7%QL&Croq>xveWKzae&w^$j8RuoAZ;g(N4Cx64B!2+y~D;UW=YZUX-n`pmFcx{p{W+Wt2K$qGNc_h_JsQZ z+aza6vj>o|-!$Pv62jRfl3w zvGJRcy%^Uae;MWyO3-z0WkFP0wnWDoZUqdKTLu&Kpd@rkkCrWyMRZ>?XhUXm*tB{2az>^v@QQaClWBFTi$^KMSTGh1?EOP)@m5l)J?FZ9^Ev?7~n$J9bY{*Wk& zXy_w`YDhw^2auE`hdth3gXdXD51zyBO}=t-P6&rC{#%f)s=M6M0xDE{Kb=@2UFbk3 z@C{gDpMhGW$|E0{4E!M(o>;^!l}eV)FsMqPm&lR)odxQSsRGx8Y8*Qt6`>n34&_|bTQi_Dcbmc_*rfoFWZ zzvR&MC4dcdDN$GOP>K-o5&u(j^2x@C44ts5utphcL~o+zGa$M#sL8uI8%J}Ws0H32 z_Q;>Yggi_xb4zf)mqe2El9@k7>-nqz5U+jFB(f{Q&Y5Lq#TAg(5${4Qq!lKl-Ed;B zSc>Z!ZdLv3B^njbIaSTlbN6q>q?P+o9&2-m>=(6JJPmsG_GG_J5#Pmf?2igTGyQZ>` zp!u%WbS)|4x+dn0W=wtU3P*n&u3V>Dyr@4Y-#gjCy!zKUsi{)>iW4@IS&qjU+n5EO zF92I|p1xKvqHK~Bt#*EJ_y;6SHWa-ZADb#>oNI?ki&1#!bl@)6P>- zegNkgq0ssD^{hIVo(+BvN-vL`7|gEZJ-8I(vbj~YpVM0bCkZsms49n-J4y%&2BfH* zmFA=a@f6JBl*4rn>XNjGdCkQS?x`K*nQA_(rvmId?>z9PJ%%F6};^jIg31H|<# z$0tU>N2DWdl{d2Du~_pF=f)32>@cxSrNJaZMg`3NDTj0RNRQpcuG!VCBL9{(AXUsr z4F)zG6-3-v3sUDT5zhyaFI1x<0u=118(Y@k0xdTrNV4V|Vh$@kpR06m9D$B2d zTCX|`)0G4p7n_PwE3r!zzLHJMh&(YSWSW|wyst!Y=@RAImdREjp?hiaLI^(}{PSRH zP*v!%(6i>~xtATOQxcA6Kub(A6lX6Y8x(EX-)z|dpH8$J{C(tEUL9A_prw@FQP1gl0$P;&3_x|Mu5@ zM;g12sl}u{O1m^o_-Ta&jmotazUrD$4xL@mm_0EKEY4&1sxTTV{jU>v=wp@40BzIJU+RZJy1hgw}FhJGX+}e~5Z+gDxOOH@vC1wpTZd4IANQbsldAQNK>2vI~OFtP<_2H^=dI z7s$8a229IP{d!9V+zsHJZ*O0eR9vLO(ak@G*8MQvyDT8Q*Mzfyzky-#MGq^tjIKy0 zOz+PHrC$X`!BAmPq8c9;QwKbzqQQtuKrFYwnk#cv#lFkZf%E2MPc~o}ixklWKQ4;G z*h6ZoM?P=#q-OP$qU%1_?LMsZHBu;9{QU$#!9z-=oSTO zyOD)0zpw1O^h05;D1lYrG_tX%w{^llA>2IA{R!UYo)wyHO?qc2+JkMz& z>UQjXM4`{WZ1sG+alK;szx_vtJ0#sOPa50CvEZTc_v7(xWy>F(LGGo}3jN7r!)DV6 zm^EcmUla@bPve(iX94&R|F?|~V05&G0qKO})h-?YX@6DdOQNpK7mb1+;duIX-SAC@ zZPEX@$NIY{`a|1J=Lb?Yc!jQjoh?nHGY8~+TD2v{t(?((ydeJ!#W5F0COof9A#^Pi zEqhan;F@(AG&^GF7sd0}i|yz6e>Q5r)(t>&U+Ay*mXBW@rt+NzMQ?HtK&sj{;8W2O zavHEim(L;-h|OpYerc)&(;sInuexmGBF8#(Si$pM57!9aHS{rC9^V&YFn~tEG+RiW z!Jz4aaUWO#w^6)&)c_F~;-M@kGYsCo?~REJ$Wmj^!p;zrpaX{_eM_?@T>uD-MXYPi5VunPjL^eGZD|B#@zi&^LQ;mCEW%>YiXhyYYr%Rf`jlM$X`yRZaAxNBdaUKFXh9NqJ=4 zI#FE?B_;C3aEU6v@hlxpH1=olb92tmq!AoqLxokNCQd%jIYM0&i-*j?%lDW0d;!qu z7Vtihb#k~>a~YjiPuH9K!DlSxvPzn{k3GQEfGAe6h)rgl^r^)mB}hERau@&Q`StOL zNz)Gu>3P;Qa!HWNriQjCU&%fN0UtYTk7^Tl_o{^Gp>(!vTQf296jEEhC?tZoL05l( zv0-220Fm?kf*sv_8>wr=J&;$70WEmqE^qjBhWQ&#zLksz>CkRkr4R{{Cw5@Dk@)=@ zq#LO?s>|jBZo35nnTf>x{B+nChVf=g;O}Md&m1>1pA!Coh!4nh^ejNX*Hm^SAh9o>WASWwlnHEmDmmHUrfEYR@2aV~^ za0VTu`7fO3=^?hMp=asulWg)A|9A}Xg5~m*?czC|eemL8dHVi_ZLJ~5DuS-tk$Q!TA{U%>$t?J56YMW6lxFNU zFr-6a<(U&kC6jGI1JDKg%f>n1$esObJF<~R00R&T78&bqK$=Hu*jUJv090qucaBp% zg0Mu_N(AS)LI0@0Q+K3LVoMUr}L zQ7q;o)QDvI?31;cgk$$H+hGQVeLu0ifEIkm9>GE(OfpQbW$?-rbu;!fceow(Wuyq+ zpZ&%3mPruY000f%G?Eoed=N&XST(9rY<%;pZ5gp`<)EyV?>%YkSn;#4&AzSK9z&wq zjDt4$Z#?3oHdK)a2ZU7wQGPhPU5_}ta#YQ~>X^8k#PZ$Gj`4q2WWY|Uca>1|3kY?C z+%3tIuhqR|Lym3Iuhqn?4DNko0-oO|7teWWKsUC#0n883pHQx8wUWDg3bT;sD9z$Y zke?`zJhN;!PR%k1nI)316d{EBpQ1LyL$Ao@<&N-HpD4VdrAfsQv4r>+K7%a3QTa%m znH$$c8G&bzI`F2(Akv-b4w)Yt`IhJpc_~vW6Ivx`nUn>@o0cC7V(La&HGDq?ETZ_#uKss zI9{`%ZDA%HU)Czd`^>x?unOJSw&%{2L?Q3%JO7}dA1Zx#NVmc0=v@U`p==8$B%JWK z6Wx&1`nz&fj+KB5YZ~#%J5`$=Y+qdGPv7Mup@q=~9_rs3iX#Bu#&ieW!q9Qubd-j{AOH>G1K z0ex$S<~A^^AIgNxx{Xx5tH5FxMX)>xg#Ia#1mRYQU=Gk#Dr{?>H$@~=Hzriq*jNv}>{}{DK;xjIfdf=3@95Fh7_y%f}Ut8 zALr(+W9bS(Jy5vK=A-lgC zToMUIug{>{g#wW{~0r2R(1f;o3! z<%Df(#OsKn5T1prd*p&kn4Er1KP=$_cQU1Gse4zR<-9C9qO(Qbkn_+YcuW+&HzKi% zoAfieeB~D_N<|3&uF(?BX+*5sQr2}OuR*$nc~B0|`yVq)7kO0Z^IS%-SVH2nmlzup z59qFhP=laQLj1Fw+sCoRC4n74H!2N#fL}Jq5$qbo32c?{9adH(tTLyCL+a2a7?51{ zwVVDW6GT5i2aEV3&uVQzs7Fmbd#<-gE9K2^w?t?I*7OH(=m0A+{TW!{+wZ7^pccxC z&cM2;a#toWvT|2e0U`wYoWZ(_BI&K#fwdj2-;X9AbYGEw2NnQv9tH#;41F<~R16I3 zac%MVfq5&ukOFCPAqvq+tDMCsF>G1&oj|a}d^;81QnI7YM?WM<&|x=qe6vd4Su?s6 zJ>#e%DsJ*Vl?^$Njw+vM*b6~U&cV7Bz$zC|J#>Vknv_?u{oZ$fepp$-4ZD49ra<%z z`@DrmhxvIzb!j z-7TmTsOU@z>Q+Y$ri4tp)<-iIXr@We1b;NpYPWe)J6$3%r4|FMJ;w-l5Yn)Ktil3w z{AfB;6v#*d-TdPE3!kN@tGEo`3xtk0!*_|V4be;lR1ldK8D{{zhQ)d1 zxF~79+fOF;$|QuuCtPwft*|wHep(6ru*{X`&z?#pGXn2W*+|~ch<20gyv3=ylY6~* zb%YNhEr%X+o`NABfaga>1XCewnjXbJ*m0<(?pQ`_2Sjdvlyb1|UYfawUD?(Zw zb5XPf6DI7YGiZ-BaGulNB_4L}kLS{>N5FXZ=Tfx^38NM;|WQ>zA@3kdfH^n1>~hz9ky9>I4={&ON2PtXd|Qx*ooc&s(_5l!1KyD z#}+Q;0{+U_Mz2*7h=s2G28f)wnntv1cDi_iwkyNdemf4%An@}-vj~OEEn&3$NO!D! z9cTq;;WmMSZudm@;elfClx!Q$bYo-^(68o#A=+2EUW^OL+cc`Iy_0&_fcgc0n$a#l z(!ttfWcE5lQIyiY%}8Na?H_MV3;lLH+Xi`l3YH=TisD>^C;b#s2FxS&B0~VaiQ_?& z3Jg^Yt@4(k_UT1~v0`3;QlnPR_g{Ud$7sEu#Ce-cl)#cC5hZ!=3=!9!yB%uHu4EBc zBa+~hoOGT{9&@hW_kF`XOD<6k-*IzCJnGxyvI}uGfNyISpSH(wu=(9Vv)&W z7VMYI`&Ij`%cqPaXAF>CW`Iqdbdg;76PE3?uYkN?wq)SY6bzOn%0o3QaZNf8&)h%) zZPw)s99Re$iZMKT&jE+!ZyaFn00i+X{8}Ys9}TTa9>RXWan~-Kuq~X~ftu2a4=imV z4dl&kU1CsBU54|pdwwQYi$ zFlmF@-&9=y~e*q0=$0H={;O}^FTu&%0^WJ}JBwG{~Pey)JJKywmmIW{XP z&5tc#E=DAWna-Dk76`52N(hsth|pSK+fsMC$)<;LrWk+9Z}kPmEo{Lxds=i5L(2a!KSLyG=dbY8k@`Tx6NJfNQ5ub!QuE_S;F%b6 zsRSYrBelyFUg5F=?iC|e*NL26W|~BL@csZ0p=aGyYhl4HCjN}={>w@-x)eok3h)Cv zmk{kFp{^36F$Gid#8&Vg3vzCRp1&-8MY1d4jy8 zxCW=Dvtyk5tb=twf*s&dlQ5WnCjErG%*TkhEC|7y&SskDA`!wO$NbIW~ZT3Wj-*r#Izi4{Z%Q1jg zdKr1Kzh|i4-weta7a)XoAgY>G6MB*DZY%i#w(Fomg_;tj{I5?St9C^sfm0R5HgmL; zg0^U)C8Qihis84!KyP|GE{6JUTT%e1Brz5{nJlPpl8lPrugn|jGK?Lc(q5dM5BBwX zg@KkLwIPb`6qGl4ijZ`>Sv*jkG ztAJ?^WVP_s;S=11Ju5o5k}LRQyM&D*yZt5b>UVFp`dNv%jXv}PKq}I^qCogH$&^M7 z8aEEv!Uc(Id3wE|8Jk{pJMM#RnlNBpz})QPhbq7@w~m-v-aW(ozKQH%pwj8lt@-U3 zGT6`FkK)wtjzJ4dHc2e6SgH-1O&)w_zO5wOuzj_^4hLes9&={9KlkKK{F2pkIUJX2 z_O?WEk@mEfn~L!Q$QQ^MAP`4M%KtwAgg|@0Qhw2CLwFP<>i(kYG)>&qXG{H%W|pFI zV{Z+y(iI;GN|{{ z)MOwHRoDFVUhrffRYlMA^j<**>B(UHYzV$grHHZt~bFSMN_mQj9+?s|!^pS?~rOY12SR{y=wYqZEg`_vPH z_C5~TG|=C$^gZ;$Yai$*L;siZ=6rdLY9f3u{1EQluMIR2PW9Zqf1RjSRUzz?sP*4y ziCyAi5$Xwaf2!zf!&miguGs2C(fRO8)rLqizCvH5y$5jirig#P@u^rJ#JN?v&R4z& z+TVrlBXMwrC-)nqke(Dw<4rL(9Kmv%7@){~rR{g!n^r{gw|lu8?Dz&_KM~xY*7)<6 z`!&+y`QE+z{=@qQlPA?B-&9QUe;)EpL8kv<&8LXB{Z7Ja?l(T{{RbLXbH4-q^w8Jr z*Eu;|`MRbl^&5W!a<)Rzr>SJj5Aw%M>)EN}q6Bj;t)wYG67Q-fcPnl&7p0i{sU-+9 zBof84x`O1gHkVqgYAk44i&Jp{D=3LXTFOu*GzYRZmallyXbDx3upH>lSiXcLQd3h- z&%;fP51odGoVJGu{U=4gV$BUzt0~reHX}bzqNPyj4%&aBM8~QPdOdQbg@Yp9%|JyE z8HsS@K#@l#EPecKXY#UcN1@+$CoebqP(^8CZ(3Sg{rI6OQCy#vAd@s$TYP-_A(A}+ z`faKrn9fIpfj&2?ubR%SfNTk!L5=Xw2W>iryooBvG$mju_G@$?x<$+G8VE$EuKdkc z<>Sr$%Ef_cQ zOUD{+mPDsZM`0jnln(Z7bxO#fktac0><}&}I6-?s-ub!#dFLDSO?t?i)`v%Cj)sn)JSH&ZYlI3jsWCp zRq7M?>s_IZMl@-nPY&G3Q@%YmiJm2tnyeLA9LHYbyeOvFnyx6MYYRCq3j%XZoNS6>{##?%Y8c;pTK# zy=i~h^YNS{T=>X$`-8gyNw*-dum{*HmhwxBs_$XgwHw)Ly^LBrHcHzI=+wT0DZmWNh307K8BzxWc(d}{; z;@8P#-QmQJ#4!ZE?Yt#41c`mW>Wzgb0NznOV|^A0{PSB&Rs=upZuv{6Hznp z`R6Tvh`V-u!iT`i#>>^XN#2N{6CGU6;?Fke8yfVWvv{}o3x>RW2_)=(yY%n;mZ^VE z2<)!wg=BrtZ<#_4{5U|nEjtL=AFT+W$u>I%*`FwVZqhg1ANOvz>`ihxCn$N|-oNQ? zd?+)rEAB#8ZggAcl1!pNjU93jb84tr$&uj3+tYwBAH9_q4g+B>s7NsyI}M1QE5^$t znl2j0yMM=`kavMMKrzX-Oq-Mv-i3d}1Hb@aVb7x=C77^a|E7VB4;5h_dNi3}W;A0>Z(FI%QE zi4sU$&%O9>Zyi1OVfO_ACe631Of(bH*bZ3e?{ubJfre_hDgYg(Q}Ef(lpTR+KU{|1 z6mLpO1ga4_U*c%c@liC@Vm&a1)^KblXw-QE8G2q0m^7Xf_7i<#HyZmN!2|UF z{^NgsWB)(?_MiXr8*?RMZ<&9>TV(IS3zFad^Y{Pwjl{A0Ec%=Lv-xYqH-Jfn?}dKx zH5~1r@x@sj?Y8^JbpN6dxJj~q@jy`U+JF5w6W-(*L{$ih{jBZMgP)}E;0Np8PhNhU z?!psd$^RI1M)E%!&IdZZ+&~OH8wHETbHU1ZcrHfb5aI~r@Ah#J3=Myd0~SuX>!m>& z2`|GsiA@-)gc`LE)`vzB@WWNleilU)3mf;i0f54<*fuLe$VMRJ}2Vc@oL$l`EK?e=1 z)xildBmt>#q!L6A?vH=`-yQZ@)~?89@dt(moaOJa=I;Gpx)9K;y?g&REK~5Kuw@4N zzE$=*v&wT6IB$U~-V<1Wut)BWLa#yVqff+N{?Q7Iaj*C_5iBr9#4%^-_ue752hezJb|q;DHG1jpqODnv6?Ey3{n))39a4^5J=>`vjEU@gDM82w7;WHc_;lN=Yg{xicCVdp< znkw1`G0O?{^1f#_M=t3aoUwYwlyZ%`ah{Gi3lBze@7{M_Q_vo#<8Y31|#Kwpd z2)u7%KbL#sxIQ{OqvZb_`|dLPcdPJk42cN&AJ`Ja?a8;?fB8SMe|5G>TjVe4GXFPT zslvBi-GYB2{NMiiJ|)2#KHWV*X+bUiyEL0y4v}XRjsi|DoeGB%#nEyZS^gc=W7hZm zL=?@?1VM8w2@C|8l^Yi^1{ev&4?1U=0D~msA{YLL!4LWdIC9Z94{xAbG*0}f8+Wh% zwTMLwT>Z=a!S@2Fgmr5iDnk_vRSs{--@88hzpj5k%$gG^`xh>H=PP^v)=N9@P`9KB zwHj_v$CAr9xvyh}kj8!*d+i!Wnii$p6O!GYlHl#s!aYr;@L*COiFc{z~ z^&he8v)u&wUs_wC?Ms75*=mCPZ{>Dq49G??*lq!6l#TkU|Y>(l^CoG&ti znv6nJGzT1yL%iDc?b5Oh(Qe+Pg~wp5>^pyRpqbz$Rjfo|nDrke^}lbuADvZT`}>4m zHdKD`X&){3zKxZ+=o|M{;!{6H`XER6HQ3wzU)l&<5t*t2Gq(G`Aq8&M_R9Ct5MD{V z;%}`KBxwH!vi;B*rq|QVQL2!Qr z5e3nm$u1jkgH{BZtW6!0-7i37JOtcie|;Y%Lvo?lbIrt5=!x!jxN(2%((VqF8**t| z*nz@b@={0Q?MA|+8((Qh@$S}D{j3AGRqC2yPl%&RS?4XPdT!GHz6*8(H2rs5wz1~L zThT{xDtdSBE=X%~*9^-M>6F;AReFEganSu}QA^>23o0f|6*s+a6u6{b5l}BGG?Wty zx8HJl#Q$=)ZU|xR^}qb2QS5&aov19Fz5Yuo50c{3K3eJ!%Pymp*DZL6Vg*gaG8X42 z-f&l7Q-dUpqaQs43?fPbkxk3cF3TKneC22k!aWpm6K~?L|7euHFqbmnPo#etdjskn zelmv$YTGGuXk*q<=3HgorRw)$M@@gCr@ilC$4UuTiBF_yES_N=+&GcWpEkAo*P~!%_`?oGbj{jFU_*X!ANSPyt|BRA#=2?T%Ys2`%k}* zLeTcnk4DMoO@EF)*HotNwM&0Y4f7HHd>5{>Y*|-=a&D`$EMbPJ$`eW7@|O4Ps*0dT z{uUMHY!x9^!MQ1)C|)xFF*rNSg0~=;QO%fT1emX5Nt#+=fQEN8gO*FXO5$(0vI|=> zkCMC^Bp^e7B}brkJjG3FmRFTc)&MApj;w*op-?R`%Z7K#{=t>Z$B2JF7d!hwai3%_ zT-R$=h16LOAc+3jfmX~}rCjv~Zr~gteNg&g;(K9w={?^@ZoE2cK>$i$H6;oK!%KQI z(TE|QmHU!^{~h%|PY~yWL7bOCTp$RpAU+KS@u>{rD}vw(;$kp}i!ulSK^zAH?6SYv zZ5FPdYPbLLmT9f40gQjLq}YnHAd=;1lfS57mHQel&?<}(y}3)aUbqsXU6{7X-n31f zs-h!kwpwnX`huS6al%*Tkm0a?uS(oe6bJJCmXrMo<1ap9K5G|q#mB@rYlN83+r?b= zAhB#XLdTrats3B#D0&T{DOb34<#tJ7qP3 z*)kqtKkpZNB``(p9gG+Ir+%@Q!%)=bM~YpI!jj}k5H!eM)zqr|iHvm-4z(%zwDh*D z9%Xp$YT8tprPl)0Ss}`SrUcQ!5fa{#U&Mau^@x69NEU67JzCjuvZqhpa@Q+;dQAnp zQT|`w&)f!4xITY)brwgv?f%)@zbFK5lI&kR5DC2YU;oX-G%&h3 zOS&qLkU-8IL5zL&O)q}%mtHpplNwi&K${@shXIenI0}CU{?EU6UXu2o2ZMgIsaZAy z7pG*gYcvNtc;hZ!J4fK3LSaP-Xs!eTG$P_~EPd=)dF*2upGN(;4#{|$AncICbx0_^+ zHI^|l7w*|k{IEW1`yzB<&bHyJl{wqf?5+5ff~$YMa*ycN527{5wN<@q4%H=Do7v@@ z14dJvIQYqu_k;<;k`DyHIlE!(QT|NutXZ`>70f7ImcBjYD z(o2&4cU$gl;IVl2)?NOfPb}S#y}QChv!U~H>ga|hP}6*MJ}okV=2#Z!PKa;`=?IpD z$VPuD4w(J3|G)gt-!QE`s*(_IIw}cCD&K16{8jk$ljP3)~3jWP6aU1>68>%cv-6@$(i%<=>u z{o}|Owlng-t<~rk;M3A>)J_PSj!u6{ z$n^jAw7ajrfBO2x@Ya3;pGcbFn9_I3QncB70nAJ?Eozj*yFXBw9gpH=Sbob6iMM)D zKg~Q|2j_KmMyLqK#-geT$EMm7h8AYj5CepNOHgEfxMLNC_Av&C0htDqRGSqou#JG@ z3{PItYcL$I($A}U)&5jWIE@|P@zZ}?_+8^Wl2wTR9Xbkr9od^H6fW5amD1qm9bvL|q)e zj`k6v0Q8Qx>O&xCGAJH615FkHA&fKu(OvrJ#$NFlr5)aC8d?aZ{u@B93VnCx(ElPgJeP$o3zf$x9ctcg}B9%eJKeO`ip@hu#RIs#N z9M!y@Y(E8ya1E_t>@-UHcu8xI@R4R&YYVk9h>#V` zP};{`2=E*(@8c+h{Bl*?=8bk$8GJvblApV^15Dty|gH~;NpR!6mE8L|jvM;?VfPUwG&C=OO#QeS9>%u;74 zcAn3Ac3)yBw{fuwVAFHe)kcl?VSFE$W9<@_&gybt3(=S*;I=MD#(ForXh{h>RA4e~9d*k5T-iGfJiwglv~+890l6 z!ZyKm34X%1z@hf%EOv=~o15*P=@P!ATGYtb&Y-sE9yCL|EUh}tZXPU4V%^sMfwq>H z^o3}bxflZwID%%Y2NMh6>(BtUoxeI`9XxBG2vE$9QqltC*l}%+MiQ`FFUc6zCP=7%IjJ6`FnTBetC9t26#F#U&iBhlEUK>== zEZSnPS=Sdb7;zdv`DyXm4gJ4C_}w6^xnw$;F(ZGf^qu58aw{}&c5GyRb=PC5rAFg? zhJ7#`I+60xz5Z6DVtTIz0jvEyAoS<;3JNXRy)(?La;a(#0I@G_wxYnw{zw#-%JvWY z|E}NX`U=5f%by)vmA+MObUnjj4>$1_Lm=HXpAw3fNf0dloG<~)#*Cvdcz$~#mJK0m zs(gRbnUOuiTG7Zpjh!E)ekev8*YAuiCblG7lIn<>!mdWHbyDJF$;inPHWWTQ36-y< z>q|wQW85(^TkbA@xNC3Xf+p+Al@sBT%qTQ9F~wDFpTwiV1wwC2$DTrSLkC8GTqvk% z&>4d7A*hyI55ci$#D#&mym!OU3x;qog*kswRazg8!^A8X7NWlfqdkO#D9ylJ*IihQ z0!L3gtk_5TjI>~Yn`GVSZDtyMB|aQ_?er@MwA7~rQIw7ZFYeS&uQ>MgBS)Y{gQCJp z-Y6`JANHvzsAe}Sr}w-(@k6$E6xnh~>_f26l|u}HBu+}A*G?RuXf_m>{2Sf##Cm^h zR{f^}5>2edMr=P8XdOoO18%q5C<^*f5M9?bO>QTFi4IOAdKJ_G3RF<1uoYK+obK4K zSSMir(YTTf%O-Ns4cK}>umOQ9mEL1g!-9w96o-X1k#C@Ew2Fa2d>S z=TbB!k{xruP10IHxq}YF#>jB}NFl#>uxWQtih1lG!dQG)5Z4v)x>_g;IJ9n2$ zriO+W&xw$=zoBM2RfDMF_D0z3Hpk{ufl6t#@JaCKJ||N@fDd@x42ZlSH>NX{WQ#)Y zdUaxuu+5a5D-MT<0yMiQX-^wGYrbXCJ zk>WNgf#?J%XIXr*I+TVu;brhpsI#>tfuz!!_kz@bgB@LY$2Rx>^*3aSj3S`)^MT&J!r!&Pee~K9d;6AY+D@sJ^>5rZ<1r6 zv88eFCO{_>Nii$fPzCb9R^RfM|NdatUoX0*g@47H4)*?4@S%UAJPzL!T;U`wE}MXy zTb0gKV+-Y8?w4T6wu<(4njrx zII6=z`j_!-y6zSKr7^K)Rr%wr2M76!-krM((jt86;~>&0v1Mx?yi|Z-rG*2K#mZd| zq_GgmtOW&@S~!28Xz+-t2&x_tmK!-mfXpQt5a=S4&L7nfu#d&$Xir7V06rf!|?P`TaM`bcZ`*}u<+t^ zpl!}}hBg{#44iqOFqik<#vKU56y{VR%{VZQ=9~N;h~$4D)7^*#qiG&k^eFI`&jXR@ znk)%7%{VZk=7FQ(`lnthO&32^;NXmZ$iuh?QRun1f%hhlOV(6MCeY8=jt3ikxZqhW z_X~RasffbMj@}9koHyqILyw~rdIr6Lc@o{wESlZR)s!*8DQ6x?F1?|4{*tyBd7P@{ z>k1D?a^Qarx6;9>sxfp(;JfUu%}yXhmPmH1W+MT-)R7B;E|c*Jpute!^^IKQ-p>pW1H&q?ZS zhLA9COp7WFATYJgMLos-uoD3eYvXyqlsXR#6L)|4W49f`VM2sU2qfwtFp16sgyC%= zi|(dT+)KisI^@uar5P0xm_O%2!cEvZ`yq~#0e|LKtW*yLX3O~)3GeazatTc$?sDlR zLyQGooL{nD5pblaS*3zWaz3hR1BqGDOMax$c36aAPz92+(A#WYTAJP%YT&k99&A)E zeT;wNA5dMo^VhpLo9-K8-BoHWG~<#Ln5NRqHuAB)y0OQ~1`kS72s+IV*ZFXm74MRC zvh#!0kfS82pxz{P<`k1-mSMxcC$=Pu^+SbK4<5LbDD=TG17O3noua7{cxMb!lcvK8 z2oET7v|bM;B5Si*8xAaaaLI8U&XW)H)=GafwGuA=*lrL7sfhq4U3d@>;^%D|Xa4FVJjp^8?6g6S77P~7Ex)~v{q^-F&X@6DI4_0l22Ja1TJ*?U3KiEMx7 zjVKjP81!=q`lIk@R4Rn|gK=T>&jS~I@WK?r7uKi^W@i{DdIjxUERM-~wZRNE0>XHo zi{A6%GX|a%U|MXBr`4{Ldu|y-M;#bdG3n$woBy+2{gMbA*Fg z0Zx!;xZ1Lvsc!*9RZ-Vi*}sv^1!jK*II+oZoZNVCqmy4>rO;MBm>uB3XAU2VuLiaf z&u<_Sa;_R%iZ3upz^RK5>`XDYMUuo%QWriou&a+*nqqp(A*Lyr7EuLSudrQU%O$@W z^{ak+Q4nk{1M6(#V3aRu>bwiK zd@ob|PP6yB@h6DF^#>*a2V{RB2zEZI94>GTCr=WlA4G4UVM?-ALvr>z{Da4XhedzG zeOP;o-g_Gs8gyRgrI$%B3k=!Ev4FQiUTdg-r4xgtv(UvlsbRnOgVj(X!d#NY9w69n z!NrsmNJ#ix{H@oL?6DB_X8-rHokttb7mVR0DSS=pt&Ty&24M^-+x>slL<`M6FS9Q( zeHnVG5cu9O;}2DQYN*t51X%(Lgs12oxa7tBBj^OAv3R*L- z2oxt@CN*1$VSa`iF|bJR2qdz98@uuIAWUF}Y_La;EKLkz+>|pm=r(X7bLFqR=q+5X zB#~;(R4@|dMMc>q{_=kfP!!vgghnP0k*Sf43l~e$$ zM`O%63J>&lbvmK^vQIogoY7&6faghzA-#AdqVVjx2@K>7zkO(Ita`ZTig{&gj zw>6b>lf|OH0WE;#wB&x5q+H{3Jdhq1ZN>vPP}h2X-d$UVS8VxOPFS9Tq!J)$D_z|M|!qf=*U%Q8-a zz7HeWPrYLp$rAMGHYB*wM)7B)M&VJ6R86fjLPDGgWuyNKII7FrH$sx>6_uR@l(&Tm z7K`2y)hc>Sj%6iki+XMx3#})D)w4aK6;#tMiLZZXole6DVycZBJVNj2ajYPwQi!~O z4$^w;gv?IEY#$3pt0ST9gJDgqQ^Tz-r=fO)Bbd|r*`8qe#gDP#D9cB9D=CE3Q4nN> z+_P3P`#w2Ig)EUQ=SAGJa!bnB>E!F5lhb7RDodsgUj4_1+&|R-=lpGO&dUwJ6XE>p z#o2#5PB8o;N9NPpsC+7W2jcms&%z(?*q!~0P`P*;m5VYJ`sK^-zyEQX5js?4t3Tcb z=Z|s_^yTx#@8<$$fsQ;gG&}Pzja+pU`E@w2ty|bq!cXipWHWE8$#bz-y;b^DWrJ>_ zGr8F>RmW-%cMN^f$0h@QBF`40w+cL4fR2AN(fq^>jk(h(7QOIU3xjqg58b%zih9s7 z>W!nRaz)vrksSqrjS8-rgW4*8HW)Z#o=>F;iA6{*a_`ggFXC_3_@}|JYmCcw@WyrM zt^V;5fymK13bW*0GY46lL8h;g-J2Hw2y9(5j&6)ZV0cNii{bZe450f}vkjrLl<|Mv zW&e@#6J!|}-hVl_u0=H zNcl*@R{XF-l_>0*98@Q#dc12@mqS^XYb>a{#|ryXm#{zmtOcqcRM;0?!Y)@t&`KVs zxZS5N#Z9i;6*o%!$j6&?oq)kqOtOFUGBr?p$g>U;W;GQPv;~wmQ2e~b4=G>2Px_GUmD+@lF8Xmxvjg__>Kp-_%H#^sW*hCofu>i`6kUI_)fO{= z?&s(O@oCtB_=EsXz28kcF(5a$mHwbRs<&S@XQ8fHzLWIj^9yo0`+Fu=pqwrX}X}seNK_C8fyd|Q0 zq0(iy-|?=XkA76%5aJC&gVU*FW4#_FR*Lqzbr@@r#$z%j-W$jwi}<=(u%D0xk8?3R z7cxj;O%cqttuhepHy`US)!L?ds!nPeX;=q4qj}bWb6E!4F zWB+!Sdfi0!^EGVKvLQ`ui?%?)Hjoie%w@FoR(cfp%V$aKCSnSj&aMm6WJ$Pjq_&1A z>0!cqDBh}tdNgRx&JXN<^Bf} z;OSQ7-mMhg!)KV2Ta|x);mS(toEmx4Cbr6smwI-WwGW?Y7kqYwwWNZ^X_GxVNk_?E zjo6hT?%GYgcIm5Hb}a~*5%5vl0HFOn3P2%swv?qo@_S*kO)NEuV~fEUiDxqrE%MH1 zAuvaPlsPXl+IR7HM8WQer(5BgLlv+_Lt87A+Jv#Ng}aDVBt_=?HBW>G=f z66EMI2a-v>vgQNxaz{l|yUd5b+XY3Dv|0G3ow@N-n~6U!jW$s@(Y~P%pB3>D(A0_=Pwexai_e)Npi9(*$dA+FnAgh3f;e@3EHCiwa$leYt7C->7 zU~Z9P>lpB!3WzOcNsX2ujx>g}UOJeRszI91v zG?fcJc#hr`&cJh2W`yVHJ=$!&yjYaIKlT!@esMDkV~T%@QFeK$4jmt~a!WHd+#D&~-lE{e-t8W+!JH(l)Sbg3+y#}hDS!+Dp~^A+dKQb!ALq|`-s8MN475V^=!TQ*r- z%#Q4imv?{HL!L>z`5DLFfg@#Zc0S`~+cS=X4r2t~^^j*GZ&Bn}!5g7j$S#eFAj|On z-KJiMZD}vv8wUMWdFqkCh{wK{fZ0pn90_nb1ML>}5J2t5C_Dgs4nVu^?-2i26#qD1 zzG&iT_vVYvjjGnir+$=s*)DdoUF_^?E-Z>2Cw6~BVM7RUl-HIUzwKsX_e^}l`%KWp*-sEle)9-h%Eo#Zbwj$6WIB6~nO10N@k_TF=dYLh-#)}5Hq*>^ zg0!t&GoAewkOQ&*^Ec7_=Wi%^9+F@5N}jy~CC~Gje{IQOzvy`O51VmRqSQ`7rd6OL z`yZwkKln@UANe=q+2BiP@diSRpGl~(r#gR#N~Yxhw%IW0i@m0ydmDJG$#YTuY6y>C zY_>yHGGP;Klbd}p>}SOc9~{RJ3O_4o_^6^cyiN4bBYJ}>+Eumu@-rqoJ}Lw|@mA9) z&MinM3LDA?&J=nHb2HL7#=+8e>>tcnAA{uu3gnR>%u_wa#EqY;SYDa1OcI28j!J(S z5@Ot7N{N@hYj|!Fh3q3uBN~M(Wl&;jYVJoh%r@as;K4w2Q@5XiNG#GkUxtH#{LX`! zx?t+o{WwgE%p`TzKJka9f)^9|v>J3m=ymfM`I6}=G}^}(JFBA^Y%7KuWkUiD>!`8< zXnjP3?Z#jk+kA8Yw-BC~&VEhp8|i<%EUU#5(kbawR@c4}Qf-|rR-aA-D{HK2TmaWX zD4#U1?}Nh&E{|lA9~9x*MDZI~q4E^R?$t0sTDjV9Y%BB{D5;ef_k-nQ_tgh>+v_y7u?V_4rJ{g*Jl0m1&G$brWJaDRAN&N#XE zw{1s(To%h^%( z33*;PCi}&`4RnfwQu;>Z#3z!UKnM=9j5>TUh~=FLi{&BxrL{R@`*8m7`;Za0q_OU< zy$+L8u z4x)FvTemBOEj5y(D-;^)x=!N%9yio4m=dQ&}@eF(+REk1vz;e#JXAvA!b-MJI0 zUP*?gDlP6(?c0zM4|n$74cDF;rT$%8C@9Q{Is=ofS<l`|G+gTKD`+fft+I=(DW$Qr&OU|&xLB2NN!DG~1X5R!6KS&|#ix-42NwA( zyXZknB2Xw=L+gJ?@^NDb(6doD)%@&H~5qwP>6G?&0p{c1XhuD;NfBgak!Y!ve3!>Yi2fa0+JCn5uk=wJm z`F9``9?dE20#I)Sa$P}!JRfIh>rr9%enMv>KoUWn?Pq@)ntD}UzZBHkew8CO)pH10 zg6y{AwpgXO+PEo3$v%h>_>^`RQTzi+=BAf+6m}Pyaml8x*fNifvhM45AsrqH4LVJ} zM`4@I&)QVJYtRMUq_>LCA_#8g-hAHNvUYdb4}WwUee*_{um^nRx=wu?v(1ldu=9az^M+pXybQC{9Lq9|4T(BHU0 zw}*eO>y9bO+P-RJXc{O;NtF~xj<=xmlPCaZeYNnzPv`&NL-oIh3`a98MrM*XQ!J*| z%p*8%>;Fw8IhrJkXA7Ed0+~h2`x(SHaopAZi-?iKf%L<4=n<5_#~gU%;9KAGVvO>O z|F;)%Web{0E1RlR@u=e6mTZ#J!{lhf>0{DlOa-_O<|?&5;BvJ%G|Lq^!o)xV&P=A|r_ zw3txwFKEkoz0ak*QuG`Fj0KP#;BMj149(Wdg1_20kxhTko4Z?<<5>eDfo-d;LMb5RBlxC0VHuwpqmymF zEy4IS!SML#gOW$avKOw?`{sjDTwN|xb!N>mEiwKSfJ^6Z_DgC>n#TSu_)P4>Qux5` z;iz&DWFjfAD{qNq8PWtisr-sZNzJb0Kx=+lGU?}ww{o$vkNlLIv40IJw*P;2EOwpC zJ6@apYj835xAwe&3-k$BFLwHbT=;UC{`)q38^FiKan!V)?9mMlyWKXv@?~k1;NqU{R~d#9)n&r#@4oPzvwiYf`qSWiTR@ z&6=ol3NN!IFz7R%%HCwpz2JW)p2=)5Lo=8W#F#c~xz5IeR8z8`9~+(MQ-Ol!&S?~j zUihqq!Si59(A()uH3JHZDrERox!gs9t{X=}qMtAwx0*b+RC-$>iIT~*oajt$nk&HQ zHSovuW;*C4oJ_gB)Mf@ld8y63M|;q&F&N#!8`q(?`p3tQN(Jblh&F$XmqE7@5}>6* zQyQ*?o*w*zwSK;!;7PfQ;!QSkeFZJN?2ogd$V_m#!BDxbfFA=h1(Ek7FfBL*Ed;QO z=_mq)m#nx?FAdvO@fUx7F}PyaukG6S^mBOn!5hAfo+S88Erv9~@11DZp!}&(4id3s zd6cl_ott&NR0S>D#L2o{Fkv$OiO#wo*;P&Ok+dFq=e>^XmM24kw7mGUk{=(c`#QT^ zd2dJ${LHHGvs;>99n1r-@@MJt4}~H7|9$|5Z04pP!#isE4~2h0beF*Z3L+8YehBZF zHvdo%%wZ7BK@iX`9O>||#n}TWAJmD4hU)~f;9 zNzho!Rj-Xe4o6OeoeM*C)qW@^yVAiKsJY&AuJ%Kj@%#desUNT}8=$=Mdo`w# zYz+!DaNhPvF8P0b)B}hVS6UB2@%vAysD3nsmV#`&)xa18l$k|Y8pIhEjqGcwUm2}a z0sHt`?FEzhR!qa~MMSEq~PW@vNg)nq_O1Wwy)Qu~lJCh09829wC2lfsp$=0~oNMt8IvQ4#p#( z>}+jgKk<4YP!(brD0Z9J>CRmpQGWb!&X(Kb z|7qys|EYgO;0t=D9BcvDfsGqHx&saY0W+Wwc|j^i0YPv8q4>)JPQvG*C*gCsi2w`kxzPK~|nP1<&)2Cf|%Bl{~wgAz?=AMBOlu;R>59h&%%k~cbZ z4G4d|re$!M;7EaIlcOCH&qhao+5p4{e8$DycJ79&pjGH1bPmsnDps~K;ss$GoSEW> z9&e`j@uv+ld`y4l+b&AoE??%Gty$#fjVgRhsSg=OYVcu@B?Vkhv9nYC zH?$6;tiy07%t-VRVdEW0ib!F=Fov1PbBz#Q|tuM?Lxd0J?)=6#ppk7jAz} z(>lll@$bEz+Hy$D!Hv;C(gvzpNz~zAN($7pOs!rVC9gg@jlUDAj7gkn5r9vq%#n12!JsOcdWesif*;re}Q2j(B`ua zTPl-(X%k1A{Kc#Sfli;9+E|>#KDU2y2*579UK!GXfZ2rC3qmjx#1TPe3pzxfY5%hE z#b9id#9On?2U2fttHma_(dwptQ&ErFX}F*WvvWKZP)B%tfTAr##?;Vp;-3bI;y(GC z-G)54e$aG>@l-b16*!V&D-O9Ll3cs6csj+z+;KiXNZ$`TrEf9mOKOMoF)4pNDmnBz zZ%Tq7dTh%K9n6_JM3%J$1^~RWLK8QE#!x?E_E?S{>vuvG3?}R*ZrzZy%nk#B$^}t4 z;>8I9ScE|cz$#!2#^FlZXtRw%FHA4fO;zrKrs$eVRm-`w6jV7Jg$;VcUp3$O`y%rz zB1>Y!4ZoQ0IZF15w~6BC1663M#2~R%v%E zVz8!MBI1_x(=sW_!QNZR6xHF%7JF<{AH|2YrYyY`oRb)s7;d=sy3P#iOc9_(1x^Wc zOqh;A)EOl0@XVZ;N&lH?CWB{&<5*2L<(>6(C381kJ+cA=4Vx+p*|>M!&t*DuVu*{Z z(g2idB?ioQaAP6*$y}^Of!2f*4fp8{Cxcu!oeXS(;l|=ECj($KoeXS@8B4=X zJkh&zcR}8$opjQ$p%^66DY50ERU2Dkxa0}lr};vNcI?Y)0NA5HUqI|(vzwYw;QWRY zzP=n*5gP-kCJo{3|%v=4h|UXjpLvs>pcX^ug~%vfKbfY0R+dAs>3~)YUe^?zr=bl zjhC&~RU#OAk0yUYmQ4Hwk}SyRVL}8;x_ZeH=79zlW={y^yB9}qWAdFE8m2|~B2m4^ z{+UF^LZyqwp+vkQaJ=<+^7oa%KErV>S&bC%cDnJ(={C%o6^7Fwle}@E9Sdd(M`I~a z+s?UIrcu1&5vx;YN^Y778{n!7J`YGco-jddViPdVrXcti5Iv%UxD@+1+Rs z#WZRUgkl~Qb5(pJzG4u&Px$#LHa__rg`b&%MHK&l>R;k@8HLOOI1A0VgyNq`D;rud zUppSduw;L2&H?kZrzFu|z{n{y)-JFyiUWaCTDF%%IVp?j4&LX1+}(kDls@-^m`=e% zvdZhSaD6uq2K(`){3fV=`%ug=2{Ngi2wWJ%2Zxt<@q;(iROkjZsR2r=*=FEmHwPx> z^4?qRSR>o8Lt+YZD%x2yTm6{e%5Of$5xj;*l&AwW3tP=E&K05XDo`Ew zwVx(1pFq3%5BJf1)-HR=OrT%=k}SxLlf4-iwR2_x)eA3t6A>t3u-#IvU~r{7A2OGI z5NLlPtM~;`(jS^!O0vv!SXT0rHM6>37A-!Po$pNvl?z0|*BNfu zNY&+oRku@pMIO9(7;GWubN5p6S04Fh&YSv1asNIoRx+9g{cq;9Spld|h_CbG{!avyjGm6E;P5k9>AQNIrLJt;XGV*+6dp=j*YB&~p zZBbQ(1aSX>!SgbTjqL}SO^L#;+?FjBwnS6Q2`w}oT*N=mDkaGP0(oTw?-4iw1eSj; zSqA?0Hgen^!(~{H6p8x z-_;xXa%Z}#IYd+>6{lrSz`^j66h5AMD=Yfp4dP)?(=sH%f;_FIUD7fa+;M-%hl>^l z&x46*s(jPH0JT6$zXFpVd{|8V06vh>NQU5;N-|_Tav+%ZIEB_4WXE54v{v}Ah%|~u zxpSxaHk1P%)y^HfE9lfn7M{PpXSMOp%}6ya3o6a#S&`gTHO7%jws!CNEl{$>d*$f@tZ(ptM56ei;y$q#-hzc)fW~g{U@u~w<8*3lkS|uF z)1F~LZ8qY5W;afK))oA1=f%%t*|hm*e@inlEGgR+`pu^BGZAWge{dri4-`tY0)sM; zg`$aIOPXL{V&y0p^uY_$9D$iOSP*)}#%T+&n^x6Upwy2$0=v`=(@Y69N?oykEdpZC zHBVjYsCbT&y6J7)?R^w`9nZT-6{62IgW@yKd4Ptku!`FsdA6_0z$g9$GVgfWbD^Vl z=P&i|&^a!NcK9QV9&0sRa=xR6WBjKQtYjxIQ+f_t<%NLg@~_udpf z`b?4}TKbu!t0EVOFsIJcmZ9EEOj8pi!nOwE+#Cl0d5=Bh)=V#z!aH_pRc5r^_(#2b zlXur=X*IUuMpCEj%Bn1d0Lg^QO5Fx^K2IXhz85W)wW7g60j!BE}4U-?R}OOKv>D8J-)Y4GW+AXP3; zI={fH4ml8z$mfeb@fYuZIneiiqQ)O5d$L(wfBoDgdZLKV{w)Vj{h5fOA18Xn-zG+} zg|tQXilm#){yhh6s|3@hBOm)XZ7Xiq!GiU=C8h=#zTIy8eL|1CN(~dUi)wm(;U297z2$ zN`0Kv=Y9%B1mB!@XqmZWK@CB2@;4nw|H~PBA=??3Ku&01aDZ->-~Qi!{LgRf|CitX z^M8Jm!j&IG4=TG9-FxtYekV48no4;0k1C+esd$rhK`=J{&zBr4c z-FBb0-@lk&e^tDHcpwmX?Z5t;32E{SA}NHye%5yB!B0|n@Pl>lC+{hKI!OMNPPZ>- znAPM2;9`jUD?0zn*&q1)kBg|HG=hF~_v?9wZ>eaO2L0#6$=~$~;L|6R|2X-Z^QTVL z55KRe{m)vLRm7S$(;~F+?a<lyNQ?XeMKNE^rIT6@u#nVoFI@iL5AHKnVTzoorG}T#1YK057n)BnLdb>1s zhbk+T+Ll4e`U+d)xcaoi^_8Ji&ILAZaV7Cqg#|#`G!~n8#d-u!OY)YJvbQAl6T^DH zkP9C!ElY4(m^7`!!3&^|PLNEeK?G6{*I7HI4y~a+YXPOu5SrFgw^L^-YlK~W=ja;L zFdW@~pn_zwiDGIP#40Cnv6#w(3Ek|1rfmsz7*w(4+KvRQsvZeJh}eal9(`KgyW!ds zqg}&#et;lo?3PaI&}(5%)ERX|&7R1(2Giq^zMU$YCn-$Qc$c+&C*;BP1GkxjqFh5+ z75c_(fvq?&9dbn^nN(3=J>y6eP(o6o2XEtlf&Vn|Q|+>W0hSplHoD$y{GsaTT2Z7S`Uqs!Z7BNCB&V z79-5U=Zm)(hR+v6bP<*-js#*Rp6LFqL@TcgglR&oM!vK4*0hBHmMD%SpkBA@AN9IX z{a_K|_^18TP~`*9{HGzR2kQ=evPNg;Uk9X&@^@i%ftU0@Uks8zSm8DTI2Um&0T6rW z1xdU5X98ELY&IH!GprdL>x3rmLx2I!u2{w`={PA3Rl^-A+lP< zQ2)1LH%y?Y34EG-R4Qny=*aYn$_^1l1G)el=pIu|sBQwGG8SCAb0n54KTfBAe!O{P z?rN*uxRMOZnM#JT$Q;%t`+-vtN2g35_YK2?Sy57V|y*! zB)tRKcLA6Z)0%?V+k}rrgX8VB=s)VSV!4{<}2@-bw)q^uE9~_S*tMSW`yGqgs znp)Fn<1br)obknMn!hRRNv{K*AQ5!M0WD4 zrdm!0Ru+!OG2OV!w*(kdg$RQJ3@kPr?MFd8u^L=^hDbsjVm`1SF(NPW^({x_>g%8b zf<=ijK!o^tn?`TMA{aNir46EkBN5~1EI*yU8IAzi#35|3oH3@WY5SIcwkCamX~8vf z$Me|w!!5lo4KeiDB4ZrpI#zR?<-y_Gbk|uCB@WSE=U5Ioc6uTTeF)zVM<_ZcC^S`q z2);B%(Z&SFD30#dc~iU2z8-CRi{zk_nABoe-#@ zvt*70R_~5sN~%;*1D?H%^4Gqga@~93g7KOYIg( z3)FJh?{F~;FG-snk}f;nm|YxW88=UsA9z9(-ude`>!@5imL!AhHFYY@a5n&N>5C1U zw5zfgtGlyt2f(Ow;p4U~QMk~{u|2k}A0=nSeeyTEO)l<#sh6FWT3$sV*OFo@P9gg# zC2WO%S-)T4#+Naslr22U%0~GJf16ol3y<=C&U}QwdHdA;H97zbGO~HU2ERT ziUu7EP*7LYupD}=Yw(9@>pI)KMn%Wc8qN%=D^BWv>iTXyNMnK3C@1Hzu)^)g00S$6 zUkp7XfP$S0_%&{?+IO#kmzxwA!es_2-~ z_e#ruHr509Jn#?(1pcy~CvAA}na?jvLN#lOB#tDJBztd$ELl)oM_`&SK8-^J77wFq z!%gx^wDRwIM6YO~G;NeUW+ILoXLHw{8o7-^*U5}Js)i3bPhm4pG75v|Mqx8IQd8w} zz=TisC}BS~g-b8euE$E4Av;>!S!BA5w#^TJcP45<)5}jcI_yV_yCp=*gxwSyp^rXV z)=hbULwVN|0qBm0JcQn^#SbOlpv^HF8Y}*8t-cq3i*`rxA1(gb&W)Ru&CDi7^#VQ= z^oaOp$?j-q34gL187e9rg+10s+}!$Mv&0KUqD&;Us>)I9$19WA-QN4lq%+o^8AP9d zOM=-P^nXS9kC%UE`2QmR#ykM%csu}H0JJ-kB?1j~R7Akx40OeNm36KL%4g(ZYcbLm;10orXM2PO$yV7nHf;OiHt?Y?orU40X@K4)gu><$C z9+X|2O#ZukeV`WmYd>^@{j2cCb?B{s{!#wzERJ^Dy^-9%C%W=2 zCeI+9LN4rQZI>SWB!ve*SoePN^5b+DaxYNPa2dD{o^>CCVk+h&nlnGDAhX-)tvS<4 z`$>rslxgt~GZ@H+R{@c=zFN`L4?JiaX{l^w{jSjKI%Q+(&@=M>SQ<~wM>{Nkc{?&_ zEql9iTTFP~gv_*-W9uSm@M)0&2L@93&@?YmLLjLP6A=i2kHxTa0B{Ueo%X`cA;3YX zR?6@sZ~@UY&R8N)AM8cZj}X1$ZG>pEsrPIuRADplurUfe8yc3ma{b+UiYHCd#Uov`@0kAB>H5oAw(Cj#{H$1q6S z#9rB&iGm*Suv^hqj2^=#QCphsh}uGJa9c2XJyP6RDSqLm%ljsYXGvyfK`de3;HIO{ zj}*Fo|D5KkQ!tgJbF21M%0?J0H|t?l)20jkt`3B zGznd1IY@`)VJd@bSR3K>&|fH%R`J8{8ibFP5Kf}E!;QOL`02eByHE=P8!(BYq%mr; z)oe+HWX&DRAgU=bLom^QG!u7i@?jxFZr~-QyiMbg5HuoFvz)oXfo47o^mtI>M(@kq z;PB_s&M50LZ%N9Fv>`2zdCF1#X5fLp-|TJ56dZi)Amn9hr?J;4=&3=mE0ACHBVUH& ztzO=}?@?=#eZCimir`}!M4=WnUfR`gMaXGzs8P5DZ+|rqhpMT6%>T#zr6GrCKs?k-4M6H5(fOl@j8Q)0_jW4;d+8ZSCj5Te!4149MKc!;dnz0r7>ppcmD zZmS8Q#E+CXyesut45B^4C+BXss^752gb&ZWC1p!hp|J>_{5es@${lOiI5!5w=ZnkM zCm(*-@Ze+r+!%SYk+3FNvmr2SuHYx<%+qNSbmq`tPX$MRQR{J(ddt*XwaQ$FJ}xR) z;KS6VU-VX>B|TF5EyET}>`lWK#V8$$`$%y&PZ2R`H9g-H#%kk#t2(+x7+68 zFti`)l{zqg#`$AJ-RPS$NnqnEz}7Ty*NtO|2UA;4c4={aMiFoEK1%rey-4tG zbNy76`^z#UmOVFT*C=t`53#uX)@EPRxI{!!B3i=2g|3iOYI;#!Gr>Q)iF zNIi>A9R>QyZ38mCBC!ab0=^vVa5J2Qt+unk(Us9GSWhh!^@1J>Sqm)``O1y6pU@(V zm4ChjRrHc&>~GU3?%_~uLKUeg7?N&jl_fmLV=NEzIZ3^Z;P##f^TxE;gd?e(i9e9R zF$_e1Z{;u9Vn;~!MDer03MVx1*Zyt2;Q+eHB!Mk=1T(E@#*LHJQXDEvGig%kLqNCb zC>*TMgRPBkGSJz=-&_r$bHq*BvY(`4w*MF&|3;C^l4&`jWI!tdJoNaK^O1X&@oas} z^JFJFp8TG3vRXAYk!8{*qFC=FLnr@uSwnq)Ds0!`tVpFcXmNBS$2{HU?snCw$JtYE z+LLBYj

    m_5wswsi*r}PYRRNWp8T|zW}Za=yY9zT$`kt7EuMfo|~h~NJ+cHnEeh% zK6tq;EuzkymWr&gc5=M1TdtGKgxz$D91dU}FKa7?Vo97d3)?cFOkz|vy`Z#@m$vAC z1@I=}-Vaud0vD-FL6-<~Nv^gtVV-M@l_Y5z`?sJ}l6GrJEX$B4pj@gGOep$bjM?mw zeQrKmgpb#tkI**ey&E^)3Yy8?oD-wrDp1Vej+1xx$ae_5;SOTdFQX)$8`Tbx=T;Tt zeoh(1y*h8Z`8?0M?Dcue)#v!kkCy*`++VG{ut)lHNfc@Mk`2^1<7J=Mt$Spj*Q`-Co@fc30O7Qq%o-066$QTNe_>?Og?bul|ot zAbH%-Vt^R9gkKqlY!tCK1j|Y2nxxiN_*qp{F%89#5+UK~^vj2qp5YFMOz5Jp3g;9RVsH1KSu&^OhWIRZ0HXHY1(aZC&H zr%G*46cQOts0_X!4~{%uqPu}aUgA3p>`umH7DTu8@U8{OOx7lN zP2H(bG&{L%+N$noVaF1GhpHX?xlDs+)BE=hGPHhg<^wWMl3>Y@f}-DSNYP4_^HHqg zN2`7`8_1XYchADT8?Li*YWAxpD3B2ZMH8i|RFORH&K>>4 zhw#!$3s$Z1@ymmM&%$ES(PXh6AY)X{ z^1gZV88MmDqneT>U9rEhc{nt~{2=IYew%5gk&<=>dU3UBu8u147P|64yCD2+-b-AJg^iHYpaOjhPzU$Bor;{ zsL%{DtBoFi;-NSeh2a6rFcAXJ4R>3^OLjpjg?CZQjz`NjRMQb;N>p2C_o&)38$6t9 zIGxV>aOhFuKiOg6hd=U!MfU;GHB-8Va6y*T%OY=qW9qz_OrE!Hl1N%Niph;mOw-BU zh7;<1J*aH-(+u5hav$|s?|ksnF;$|QbFE^(abTT)2ai%B4;sIEh*a`<(En8pGSHTf zjqaqRXO~71<4I=6E)DdkMjs9B_FvGzEvKCE+BS{OX%CZT;{Kieu?7zCV+=67Y> z>x4*u)_AJ5-R$%_7gFr-*Q!@L;ea%sz`=^$Fmbc;e~&@745FHO{lD&Q{g9jJ3z+v*tUXjF} z$U&znRp&1avg6Gop6JPr1yR}l)}yVe z+uxdO2tpa34-cXxR44A1(GI-baNUy^moXBgVU?d8Vm?R;nZbtwF(CH7+i@B zoB5E#m>UY+r;e~&B-c#=H?9KU<=D>dqoiLK&E}d}Q$dAYKpiwH<2Mc5HH-0B<+?S0 z>*q{mGRtB-7UGpCp!i3NUrq0l9?`4Tv{G?EA9bwQ#i&o}qK3WmoP|D#()%8%Pc*AM zHG-pTqs5-sVY2m>?W2S*;)mc^HFYY~CkpXCpApkLCZka8zi6J|G4o?k@4i3-z(E%U zyW~DQ5xMi9x~%Y410mbyyf_X;9AJ@uto()ycrs8U^Eq60NuMo3zflDoVLQd6&xAkx z@n;E`nWugHo@StB`5JlXVMnVU)@4k5>J8dvHU z#&O=ywG(i1m_O1&3Iv$W?H#+vD(baI+oHo2CMF)qdP4wfc0$YBhku#37ejd(QBauHD z4Pw_1FLs4D7ihIUB;HTbUsh z?o`ePQ8{m=a*k9^K;_eaAS$0)seD2zC!lgMh{{DPl?$YD0xEwDqVh*8l|PWm38;J? zMCEfUmCs1!1XR8ZqVlDc$`_<^0xDkzQTf_R*aqIUXHsVl7q5>yTia|ZCxaBOz5 zqRnlRM!kdCtm(yn(v%5+Qac+fm}7v1coDM0dpBGK_1!`hJhnO~swh_$3zZMgIXVP9 zm750cP7FYL$iQ(C4e5$@fjP}`gJ0Vf7^>KEpJ0$~JI9dFICu2g)!0-}VB`WxTs(G^B95OW8&?c9S#wszSvS411FAUXxVaw(`A@ z>>B6FI&$1P#fgLY!{16_QzD?5g?TCI@H4I`JSh=13SaIMVZVF>8&y*eZWm#1DIFYK zUdRcPv<^Xk?;GA~7p~lJ`8*7fG*dN$-EAn^sz_9!yjc>h3&%6`#&c6UDQCD}k{1p3 z%H+AYa9A7&C3|&p^LhbsiOz{~X1|~(rfu0JNotgm<-d0zt<^9-nx5U3q-vH!gm1P4 zDy?j25YRY4@PzD5O}LCU+W?jq!}p>o&rd)4}=BD0p>wx_ljBtF>2WclnpAD2ybNK z2QAMF2oV^&r&RXBb$V~MUE|RLE>9OYf(B90wdKfEomq3I`Gya?#{KvccfY&43p}=6 z<~5Oj;Ili${lEQit$L3_uuI@8YRw*;7cme%D;OyQ@8F=Kw7kL9VD<-iY7`^c10&c8lNVAe-Z%_)F*+Gq_N*Xr7ZCO+Z4>rt+2d< zK0+x>Qpn|alw`lDsx4*W2*Q-L5rVFQL!k=Pp(MLV>VU^Te=GE!w}P(>{AGr9|JDEe z4dd2h7^z}X61rCc3BRu=LryGewd_+^qQrA+UC_8ficO(5r`Rh-gYn!Q>L`MR2GZU9AV7; zTQ7!V=M4rjmnPIu-zQZ0MO7BW{OKxs42K_*xowHsq7ttl5`IW5$Z2YKchk-DUPl|p5?|7=Bxt%I-4kwF{(ci3KN{Jz#GcKganI>`NmVhFrd@S zONYWRpuvomuX9DGi?fm<>var&so;ij*-mxkkl75%k!E#%7X2@Nd_->J#0pqZY~9CEng+}pc5fTDG3a1JKuu`| zxV?sES#sw4l1X(T1J+UaaG>E(3{1 z!3@VFijp)p9R2EvSq^8SX{NO|9jK>H&!x$PcOa=+@6R|*$q5Ivqzxn5$QXgCWvs*s%YL;tiV( z)8m(qbhBaq(hMaV1=9^Wr3Qt+RyF{lRvXQR!Y9|ygRxMR8nc^!HX>N884pD9Lw~c| zu-38%KYd>KA$0onP*EgRQfwvbE4yO5F&5BBt}T!aXGI1+*xT8V>s~e&lgT;x^D7>o zafrlS`Yb%N3uo5-?wM!<3*m-cIy1wP&WUmK`eP*;=!bEG!Ez?>wjaQtw+&Wc3ovzJ zTrvjO3HzQrntNe?JAhz2?1_mqH^g=j!JgO?6H#_S>L+P^G^_)PV#}6fT9pAYtlV(r zQcp~F5y3u7E>2d?!HTv~5JCLj-ON;wury$yvG5%mncfA65$(cN9NqfiP$Y(CtD>Pz zr1Gd9_FwXYVtW7HK`qR0m;-BpV$yFm6uqR%Fc@}e9J$ngEw#gK$&RqXZf&QV<=AS~ zhJancq}HhrK!ywYls$Jfm<7vlv4&+zuwDElSY*B3gfvo-^)?fN+KL;Kb_>$Rq{V_@ zAaeW!zUV#pOGsn|#R%9zk+E^~-Vy1Q1jR&2lwXFx4vLIuR!+o4fF7)Th3>;}FoLEQ z8+9w4eCP;&A5R8IgkDj)l0q|e!_{qj%$T784l3OjuGr;b7E#3sj=;PRo3^S+CmJlC zyaO5Y84{5j#SPu{TlttbkdIU#52lh?^}-75XF1;N_{lOS<*f=xtPxCQE3xhQNyfWHi6wkTo{->yN$)%U#`&u z!j#yZETEl?>H=_7MqF@+Uh4Yb1P=uwQj17(W-w|X`6?*OZ# zVK-8LHedF&zsvn=c9;8!?#uZ#?6|>llSx|K)7D~8a(iyDq@-!R+{cDS<&-G8>`F5a zv@NGUAl>Grnalf|n2)czR!es){%-EJ+bD)8u?9jEi0+8LJEpDcngIbJ`dYlCe%2@T zvlgl2vpz!V=Y3K?Z;?9gG8iHCPkmDV)FO3%+`)ak)EDj#ZyHCNUj4oxm(-aWn$n@^ zF*e`;;%qpGR^^W%IDj}G4x-f_AP5d1J`D%aY9bKC7!dJ>{tIHFUJi!h(7&K2)M_9Q z!-y)7m!=R0XX5P49hua!Sc_YJg-KK92=m{^W6%RPWzB3x6nIx>%>;CrSgd&s`aPk4 z0Fk{5h0k61=YxdL-i2{7cj0#_pbCKo1%&B|qsRAI_vU2B24DqfKd)a4V`xI&t~s&U zMKF*Vwbk-+9Q%8QrCiZtRhu);&f9U2=3?aZGJ$ zfkO)YNOHMZY|3`_V;Nwy?8D~)vRBK0x8+S)Jbd$YV3ddaTlRoI8* zM|?eiICdNbLvF76Uvg8b?UKb3J~!l``|5?~9 z4@8Y}ZMi(6E~2J85W`5d7>3z(eAjtVS9f7A>Z++U%sQfeF6t-K78Q1XuX!89&_`l- zUXwUz*H{d>a=a zEkWl#Asro7s*Q@ec|uozE{+B*T&2lwJQtcGSw@`@bmHO&fkgdnh6*xw)E)|*fyEXW zC-EQqAbkO~IegMF!5;i6J*2J zy5T7E>U}$$$i&TnoctX)NpT8*)u5LK+4vI#8Af>;bV%S(IW6`$uv;-w8s_1uYj4DX ziQ+n>WGRj!)pkV`&1-Bf387-7bt=f{GEqfa8~Nb3Q^nNUU@fQNK(r()R=KuAwv>9f zgk%V@Q)U+I*NKyV`f&!vs%uQjfe+KBu55UYMRXesR&7$sVeC4JoH!{_!_70)HFA(7 zv|Q^u$b=A6b=Wb; zhAj@c4V%oM0LZ2-wt9_ePQ^Rg;Bmsrs35mBzQuJN!l)>JUeIqbt`mIia2zVVrRr&f z>#~QfB*vQ=Y76TzKo#2Ub>EK+|?%WVlE+qg?W;$g7tVVK#L}^B|&YJOf=!*y#=xb zB@X2HD3d zSqGY*eX6rFBaXwA1#Hppl2{As%~i6nJ#g&0Be6xl8nJJ_!=l-DbZ**NDi+O;rblN< zI-Vfm-01u5D=%geg{!bxFVS7?gb>qE6-mLVY+{ywo1Q}d(p4U*f&b86BEgVL1P5yJ zWe|Q)MPU_0%;fPP%aW7{HVb{`;TUucfTy-?ScP7*5NE!ghQ=s()Xttqh~Ye^NuEbR z>jevF<}EG5aiCg`_a{Xo&e}$~-}2s{pw2o*4ynECcsY_2c{$jm{<`;dm+8VHa;;T| zbtXQ4+{xPCF}(YLCo(Y|<+h4ET6a$5HUDe4-EaGV*T}u1xf+(X`E7h5vV01ofIZ*l zSPNa{TmjUb2NQkkB)D6_dJm=40q89%yHG$y|0)>$Is6p^(9hl4f(i7m{J4XmAAlX~ zJo;Atw_Vx#n?O#oZ+}q@c10slKadUEvz3K^P8`>&#x%c>Yg{69KJ!lYT^{~LCimp?L-HT5#+Y(5F8pZ+i(#M5~8zghv9wx|Q0U|l5^m}(U zlg(8t&nPG5JrqpfK-OzuBO`2dao?eTD5MTVmVpr4BW#i}UicU3D`qcwkXfJ-OtWCE z8a-6Z9vo^z_;gDx8+5(Jv$)Gk7!g;OvoP2E)iXHn9v0v+#eqtxv;@yxzc`CsU@i*e z;Bmhh;i+Xha~JJS8h3s1o&zh`CZAafVeR92nr!Va{;oHj(~R39kFZ?bn_Gr|=Gk|o zHtiNq1}7T_=gTC0+ey|-{4_NX2=Y(Buwv12xLA_gyfb#Nk4*)+Oc#LP&5}{UTo`%^633Ej&1^fZ=#cqdw*cb2SlMC|4gpj9}sL*lE8Fd(A=! zu&&BrXNZC0b0-vhKvkU>3a&>|aNVTf!zA~KTdx!U&=ef^bq;cHeDIV6?Cc03;cgXd z!(I0Ias&@|64eybzP+qb@f)585mb<9_w0|LfvDz^R4Mp~J!c^l*vqSb5d@S^oxo4f zDT{(%&UWJ%knL)j^n&26GEpSZaTL^AX#|asAOfyO;eTC&AHz~X@c%Lj{$FbFV?Zh< z3QD(QVj!#5u92`#C#FvKyx%^KDbX!mZC0ZIqaaZypgBdN{S4G6Nl55|#ZaJKjY$L! zkDU-8V-PBYfMQZ(bB}g^3kSut#@hPqi#d7&ku*H*#uG8GrDbz$+K6e|kPl;c2%Yc^KxVTOCn>r$HzU zqpcDUQ8P@}NQEH7^mRAREZv)El&0w?JMgQl3qPWGVJVVPpWiZn(RlrL*VdQdziOBQ ziOwtVm)|4&-0;)KFt%gC;&&3Cb|Cs}&pnDdi$y2%YI!Rw> zoTn`tIS$jMpod0(En|LIeQj6|9@QZ@t?lN(;R#$LzKk6Ucl~I&POmOCe-o}cXMGta zTVP65Zz)?>mvBfHO0Bc-Gi!R{=@7uhhwJfNe7J7m;u5*wI2Ts3Jt3oq3U(>^l#A9= zG0lptcX%qsp9wq>f_bp_k6Celw)euI?amIjXYsb+MEI9~s1L!flg3^N%-#f`e;3B< zQPfCj_9964PyO;)LH! zvheE&0!+hJ?i&r+hR?IEr&BuR!16o+aAw(0F5002lNrB)eS{u7HGO zFk7H=#UrMFsVWj25u-X|gx%&uSHVxmEJ<=ZNI!?GKu&>*bPOpo!*D#CTDJ-u6xjmv zRqYC4!B5OtvG#EeRi5$0Sg!6US}P~mtQN#cvK_^QQN3-2i;e`qfB%?#9RmM;W>mL( zVQ)@c5XHR38yxsCoGSc9mnX+oov5QBCF?-)b3aOdHe*hSCmAwyvx!4gV^O69tAZRG z@uFz;49~9M(J;%yRkjQ_&#bAP>|Sn3$C5l%m6pUJl0z-Ub`;6>mdavT^tKK2!7G06 zw2z13uRwz2m)PHitC^n#qv??!bfPJeHzRg!%@uMZlAC#wt^x&GCYvwX-SkUiF)F+Hf9V@u?@8u zq~X2+(d5{{^IK@K>9Xc!(1?j8WCkhDTNs%^a#M3FNQp>FAkkbUaqfdKHyuq3WSNqo zI|PKfwau3}EMKe%yIXJj3X?6|+{s#7WfIqa7zk!&vG>!pG#|~&!X=jM6~BOc4JKp7 z3DPZ7TC#3SkoGL3Yheh!(iA3QWK9=pwJfLu=Y!sdgRaxd2QT#NE=jxcnaaHb_~*T8 zSk+7hi4aAEvK>!^qBV%XGNvdZtRPGFP>2~vg+*<{h58Fh949hQtDum-kF`(|Eky8t zD0Q5K4m()wduo$4Hf$=njfy1R-xNg#tKp|Xl&r?F!K(KbRgLQ99MqwTqN7-KI*y8B z+i8UcoX#wY29mCx!yGgGEuGCjMG~O5&$*q{~nZ0(C1xpDR_zf#P6c;Z(AZ*Kf(f zXNIfGZMisVf`t`D{IM00T8AAaz~aK%$bVCDN~S7lEm5H^SQIB9LXm@Pm4-X`XdEk` zLIGxM$x=-C6jj5bu3m+I2g#HD45y>`xLu2?{7H?uXD{JIcp#;#wKGuP$P0geIW=S% z`0LKQBL@oLOh9$eTT&v|TeHXm2M?>5J+3FF-ytlqCEar#Ov>aWCaI}O@C5K6FU2{N z!*}B@=}sYlM_sj8)Rj2QLq7r=w3hwc?F(fmhgvLK=D1}0<1=~4jk9z}6jcVQ;1jo(j62lyB^v!*Lx(WQpDCo!E zbgcy?Gqs-mA_e>uTzr^?c|ZK{h*I^s2)zi~qb93Q!MY!N(0biaxqg=pO%K26VY0iv zN@rnsnAomf=|uQ>-+dB+2fvuT4-c zi#+@cT#sVly2-#5G9c!E4165Lz{e&7g%`#%AixiN80QE+G&%SMIS_LSuEx0nc&x#} z2joBu2Oq{c19+^#!LP`HpqTV>oIhaCHCQMT1M~<2;?iHnxdirHgN5Ia1uGYbYLU@E{=%VtBZJ{`t3Y&Y^g)!GnxE z2+Er;ejDc=iU%7!P~<@j51OBS8lpfW_Du!-IifE@EuN`KDb2i!;w`B@Izc44m_(LRA?I#}`0Mfv72#VYE@Hcc*P+q2Y)vED9f6EQ~Z4#~r zV81n#TJD8!J1^`KWW58hvr+LlXIU)l#ps#=+>60AI8j+F@Jc)cyP{V?$H~dupsPu| z89-e%^y-9vMVye#4f{MwIJyG=tyxEwkigSHW zsO1^Lf9~o<`xSd3g5Uo_0ycy`u`E(uX?TV2J`ePTHm=|1ODeH#>~>E9JlW^T7EoUe zp-)_Y$IytQRA+ah-RGx(B}plWM28rl_uzGPQdNAQ+Kit7J0EiZY^U+|qvhuZ-wHNi z)*E$}@LP1D*!8dzd*b5Ej|>9zkrs$ebH*mQU{9?2kDWuDUl~xztTxIS+vNPvyYV`B z3gcisiUU`N*I&`8+`ekqt7Z|>dD`b3&Ut3BV*tHjsQG*U{gn43r zTDXRF!sfj=XWg$yto!PQH1Ps&(}^qZ6~8yO#^;&DA~iCw)4)&0EX?O&5Uq!Jm?@4o zSEyRM<%qooehTJ(I=0_4CsupU=Nil20?tB|tUe7M1hzw|T5d(`1ssAwrOV+2v?*Oa z;Eg;HA?kW;ftBiVM|JfB_8tVBg|P2`hTh>ED76cEAF$6LpsrfZIvK30mcve}_~SJ_ ze*EtO|I^r5=#G+`_F(7(wix)SkfPK{J_UnkK~gQxF>Yw>G+aHre{Iyv?JUE_zJ5%90*@@KzvbKWr1(;`50ezV0>8{(2p3OX^gYyr@YO77~9J^ zj^Yu}QP-X9Ic$R%5LRjsW3BQ0s7^|@Yd^Px2ofAUS?_mIxbi#qtw@F@69>{96%rj! zH)PjT6^S%fC!<*rLI{ap#_&M&>LnvQ4`SfA;d3_LcMJzM(aK4`DEgm(3HsGv<(i+b zp2u)O?+N@$ zTWaI%yeUqF9()G9g^#J9cEnC6Fu9 zR;=O~^wI)>hkp$M4`0-PM|UjZjla4ae&dU0@D{gd;Pu%U=!>T?Q4t6_lVd|pl@n_*a$Xs1c0A*&5Jn29=^s)z+$2Ak*mET-&CsM-CsfP{I8>4 zdiE4v^%Wb{4+fX;MJ>3zz&ZjK@>;mdhU*BLV%k_ome-K;2GFNRUCBwk0 z2C7fQ0>9YxX0!$H3$vck;zdwy;MEWw^@pHW6=)jPZor|=gd6<9Dp~i5xS~#ftzmwNbscU7Og|hd>X<~SR&*}$dIcBmB-%au!+tIqgSV+VliI`{Quee>k;t(;Swz8i+=ly0$X1bw}ii_vDNyxSkUK(f3VC} z!rxYB!!EiI`1e^b0)5xUi>2aC&pOO@!1r{h*wo1iwwsfZZ)2@b?NDUeT{B8gR(3 zuGg01QVwt-2E2^dyXd;c&lIT7rw71hrYN#xz;3s@P+ZUkvt_ zW3b12a#M77|8p@0`|4=;3zRkp>Maht-J-Wx_qr(I7li+?(=G6?`&=yZbK!69R>Q&` z)09xwGZFaE+$we>_CXJ=t>PIJ^oRw%Pfl_KzNRIAK?SD>;4eqK@x?PJ;t~7C_esZ( zz}IBsDBlqR{D?Qccm`*}i+khYpF@@g{#`RP7|;uVedu*(BQ&e9V;s*5yOXfm<&cGU z3|6_U*?5%f2m=3l6!_IQA2m8+V)?!qrr)CZTHgv)I=tWyb!{2+cnf`k(!row;edQY ztAHwh9bV{_rws$M7kOpAP~EB+A2mAMz;8zYuQh;2b&eP-KNMV+cD@!|qB@5^q3Ts2 zmkCu}e~gM85xDnt1rNBR4o7rk)2}^dus4*)sJ#(n;)h=NcI_FeZ^WQKWais-XIP@= zMSoy?BZIye@@`{8Vi81q9cd{wRe8bDF=<&Ie4>53eqnjjQp3gTd_3A%2YAk<~@a$vHq$_P(vvc5`-BSvwi7zTz9!GVFs89;@m5C$$T zM;?NU%jPLynpyfa58@26^uw=82{@|%_rLz%f1lWY&`%!o{BWmzDh_avl z$It)uCz7WAiyUst-z`5o{0-%BNh1w6VeCh(A1=~lzdO3azuW_6-F$~(ESACQtW zJ=rGfUVW9P8=4{0y0#5fwS2=H)9r|@pq7T>wu!(Wm|<5y-<)BG+d#zt-&e)?27P@8 zG`3PW!Jnmmyn5~%?8U&JSwxqXI7Dy~@QWhYAo#^osA&@i{y^c3A>S;Vp^S|efA*qe zT+|Se`asJapQ?jIQ#di{?SAOlm>EHAIeoq*yo z)Zk2U0=Q)-xZeKldQ{Iqld)$oApt|?r-Z+0 ze(-*a81VbGS4Z%1$=oDw{*dNS?rPXzzkr{BLJu^AexV4$_JH7be^>(dian~}gj=3r zA>23gQ42Q-`d8!7f3MzbK}nn-^smREk288EdG~)Ahdz4@OaCI#AE5}9J1T8h?H2<7 zfDT%2Z$M&!UljPijzhmX6Az30dv5p#HPLcwe+8Gt@k4K?WAa?PndoAHpCA1Gtp+9Z zjlBj~*cb5DXFES0@!H!a(Q#my_!1i{345ay@aR%_JyCCqb;OjX2;e&ge z<}(2YV~h}^plN~FMJ3eva5{o`9i}5(u`VlC!wO;9Ul;)+?9h>erX|9A0D^cJ6%Z9P zG_4U{0T6Z=f9x+|zIx96$0(SGX_k*Z8TOsxNK1#zRO-zY%dXBoEXJ^+!w^l8>YvGw zO6mk*eTnM~DP)Xpls$!`CMJ-LGGLYMwn)zUuvav#cm^e-Vu9~d4jq9np25|PVuA0I zNgsi)iKMZ5#0|V0_DZA+;KA#nNOS_=2j6%AzV^oBe*_6`;7z8KxV)GRU~e*|MEMvF zjSvsNHV%IF7%D`?!~Zl6ewIq%qzHlV7kf(wL(F1xX)Vaa$`CjBYMwkj4T7&a#(Z7_ zAN8T!;18;E3-H^-xu_2n0sa`fQ_4eY?>_271;PK}Ivj;RWW%Tuoq~YDM7P8rb)pmG zy8Tyyf4`L(Y8Qbou-n4_^24h?SWadF>3TgGWr{+uA9lMY4A~$ z$p7BEW3YEyut!azm=e#2pYO+%c*@6cv!n15+lQY=6`0G%P>whO{-a8qAAYWuI8lu# z4F7N({?%L;RfxjyAJt(gA4376U@gOjmHEdAe;SHPe|_{DR-3sw7`TvKz~8)&U37af z>*DWl4Tk>3dtZRRqRnT%Z0rZJPm7RB|1mR>_p%XjQT8~ z$IWch0N)qr9D%RJI9T2k^TzizRldFRI9*lnTR$jfVA!{58L+%50Q%lBV+Z8xL&i`z zf6EK}KuX1MZ)Q|@yP6aBU`$v^F|3>qH;+Ge1 z@zVbk;19m}1^Bf$A1jz*!2dV~d-f1s_ZRry!&A?G^fZ9IMdwSR;${B{zz;`2UzNb( zMSl^%N69eos)3jM1-seaeITWsudf3^%_TSNgLUHq`8GWQN-jl!KcIL$qTiIff8qit zZukf4#|8FHT>>tD;sTyNu7>N!bS7c>cp~rzOPB@tZ52$s)Xxk4z+!cVeACin;g}cp z!61hL-xlNGlvn}K_cq55$k&_WD0V#yc)In|)iaG(%EhnBcKhp0iL?AJN!N`V{Zu2C zwDhPhdGIW|Px$N1Q*_($?hH%zf2vpe@fe6ykkua0&t*62? z>>4R(r^Ju~h>qstmZ&XE;IuChO#CLl!DIX;qsNG+Wn-kr047>I2DSsl9*J=ls&Xot zb_&O{31a1TtjhpG+Fb@lR3e!8MS6qF_yxYgBx6FC@ryLlWdIW`E(7m6e~LX4<1AF= zR5a}rwtB>nGTLJRAMG9kX9^3TV!XdVXE9}dG0s!8x(VzA2|Na4Y*N32Kq-a*I!1bj zPS=2;lL#+;ec`_$oq(r1^9i(3g7_GjP%ti9Tm?>~6nrekg|O9=(KJ`6ViH8l=%j)% z(&0MrqKFtW9^d3T9?^A7f7-nOgh#uM$2Ql&uJqtYU4h49tf4wR87<}tc@cCx-rzeP zJAB6__PxcBv3is5SatdiRBH<2W3=yBwN|LGxhMEsjI~s!M+0R#Q-xNmH~5ZKm+wGF z&P@hmcC6>Hm4%M&@9A<5_Lq(E8U+v7)tHKcH#m&iiD=0+@QSYxe@@1Ei-L}JUvY(7 zKF%WI{>s>`l6BDOBkr#}!;}n}qGy-}`Bsnc4fPg3fTDgOuX>xoX?xpStUflhIbZos zi+}p!cN%-FDV+(w(r4xswD6)WywYXd6^!pi!aQKoPv2~e;f225eTH1=4cIYrIumvI zZrNwXW$$i@mV5%xf4gjX0eDN8j`vL5$}0d=vaHzak7Qz*S$AzKfLs4<0r5+SHE2h82PK; zybILtOapz7oiAWVsm^3?d$+Nvz3^D@75>r>So_1P-)ZlQf2|!Tbv~DX%VC3miDLgr z4E|-m!M|)Z_}E|Kf_#+0KYihGkb(HOe%Rt)_E~&PZ_g#b>@)TzmTyFxd9%yHo2Z=; z3G;weKYgkT<=wU^?<{fsX z{-)y)Ht|-b+sdDyk0ySCRgyD53)aJ%JZHqFGVb!6e~N%*xOpA|f2k~%I2lzi@M`j9 z2zS-ELuWg|`yLHL&tCaD{CHhN4E+B3-(%n>^6z-5Uhvzm`K#wJ4(wg93ZKH&FGDtXRcExKBakX;8?AYtV5H!_OXM zYR(!5`1%X5NZ~H~eY^A5>vYfiHu9-xZEev3%agH=O^DO@yR#NbC`WU3P!+xg8W}U{g?mAhR*)4zy6B<`Uy$kCxOQ6ehR35 ze_Bua>!<$*p%?W2oBjaw5CT=8N8|+|uZHobAk~8HW03Y!pep(ewLFb#GkTgA{Poj+ z|5x=7nj<01Br$lHZIF#3$Iur#(Wu?ZPmLhtM+861m&Y_*Z~fgEewGh2OOZ8Vw(|2o zUw{0+{`++NK-kg_CA6G z-XvrXPj2F1{V(?8;vYX2KSsJ{|Izcv-*goOLA|HwMD^w>S=35_AAhd?nTDCxlk!T; z4|ilvDCtVXPbsNo;PbQw#P@rV?u}0BaxUvn`f0C%j zf-+CBA$_+Leen+*oOeo*?B~9c$pu(R`ZB0&9BfF$Q4HN%xWodP&)hRDLp2s|wJ3Rk z6bYw@?!q%EqNdWM2=Bs(rbyZDf08tpk~oLM`gy~lhoX72zl8bfIrkr1i%MjHLzCOF&HN zUW(ts7<@8rK+hC^dK)nyY|?Kqz7|wpSSGpYLrlihWyWI^Zv5`*&(d%}R{#N6Au;oe znW`*EqxggNOAH&5A6rQTf3m;Tr%`lBME4+-VfsJm<~vjl-dmyc$c@BI7DQe_ngv6| zNX%BTxQkkLH4MfQ=`_TQw_znW9Y*XLE7wA4>A!|rC#Cf=>eYPy^A$D|gi%r${!w(W zd1O`NB_R*Oc(9B1oAucrN5-K6XWf!U`x>iXf=-5?Zi0L?BcL;1e^95v2y-FGh@dml zdD)_IJnGjiAkab(3ATF_jqt|5z=lrsC+Qh4|_IF>>EXAT!%g zU8mN!M-qgP&{JCf#z3>2eueOhiBUI1eBlHEtB@xw>oD z4h(n^EIIM9Vx~zBA+8)m{!5hjYsK$9Ev98S5b1g{Rmp>D5H=ajsrwTog_D$1Hk4S& zGviAP$EUkIRgzO71>B6MIJRfp>Fg*qN><=(kSA_$L%*_{4fcMw15d-08%q3?jPpA5 zzPQj}yC!oue>U?!ias~G+z*n)Pgcxgf(B(nJn2PL(4-67g2EYMlSTf$-|pTJys`Nr zzq^{*6TC5(gvW=I9BXv8Y4v2A%_QD{L9_~TnY%Qt1wWjL}WwsS1GbXhJmU7Uny!FIKK z8Nr4|HOYKvrJ{&vaYW8!C48nx)cowz+iLj5id&7?H?4O;=6LB~Dyr<~@F_ooD|@NT zYc_70f8mDjh#oeaZ62i7u-+(Pk3c1!>DDG9YoOCMg{tH>{> zd@HgV#GAZhdJxqml^jNVd+bC|ec@CG1zlo}f5J_K{R}>19254Ed5d-`E|3atDoiLm zu3qHealhGgSKyCqu+pRS0B!l1yI3@8@fc8X)4`mCnTA_GeJMWfr=xHdrUf5b4_@&j zAAl4X?CK&xRX^|Jet{M6$7rxVrL(3!h;YI2|oypM!6I6D`Db zf56ArX~9HLBrS7)8%8g0qGe7rMFp=?o1}qRh(KD3kKe>f`J);sIBb?<*er{D*)O>9 zr#Si2A)PA%-eQ;uc##_&6sUMxT{Hnw^7J%_zGM_L88GJ%4E;Lz90p%Tz%SEVh2Ej7 z7X9|mcgZ07bJIX)EE;$%%vOWQYl_W!e|P9|g+foiu7X|n6_6ABp({bn#)S`@*)GEH zgkPaGJZO59d)KU9KgUdfAADo$@0`R=hb@r7_E|cHXIoW6gfsC4(J)Vw?PwzAmZ3GM zzz&@NDrQL_I2x56wBSJ{Yas3)tcv?Lah z9BL`Hqeym@9Bc`5kkeoU%FjVACEH!sD5)kLj3kM&?Y^2>pC^SbV;XMCAqE;WGtXn` zFyO$`pv#FJ&S@F58EGI8{F*B!9F1^Y+_krY$p0Fw&!NyRXw)5g4{~vne@$prVH1Se|i!>b=eHv&{5+jtz4fVAxAjb(gnK8G>)ECAbs zB%!)|4~vStg)Jtjq+bKb1bX{;OjHS>358f6?=6ao>+N6%Pv#{N-~P&08f)~X|+;q z9IXEpCGqBmnKWnRf04D14fv7t9IQSWar9EB!g5s4a&^zpC6ECwsdNKhst@0x2=P9N zAlXa2>Lr2L54!Xn>J#r1ewiaMA4hmaO_47q^F@pXmfz~D>R(kN|)v2$fcp-*?G)H|hk zL0$wGc90uShx;qTWU#9#AU8YQPQgp_!ZW+q2c={mk08XNb869|Vs5y#?RO}%5y8ms z`|WPFe}96fhuJ80ozL7kaDq3C1s)D9T|@S#CF}4hYn*Z(J&eerzC1Qz=2fWTWsxBU_Vuad3v2ZDn0vQJZz#~=Z`{^OO$Fe?*dDN zd`BdG+2x5EKBj(em%@559Rr#aGmF$Z6c;#)e^kVwkRTUVVi^*0_#y$}$>6all5s_6 zR}PD>4YxMw0IP>0h$$4aGd~N487U>RGh)}=1{M#wh>)YiUz=%?mwK^5M=q-dVSCOE z2O4^vz8ouv0xG(%IzMK$1`E27e^cEq968vlDjirmYm9ct44Y8?swva+t9TNn==kvkwxr_~DkCAL09Py&(dj!mE#E$M+6*DMw?w~2Z#vF#y(l(Fe}OD2Aa z{SF~Ax0j4%~)CIfJT9_3(|r6$KO<-kOCSewVGFu zFR|OfcN=`?ugY4w9K^lyD%B*?f1!>J9S^;(u)4(V27h2{+asmwz(H&Fjk0LI(*W)9 zAZ5{081KXUWsnWlABXl5i=GtSRh)-*TClgle>Uh>HsR}7OdnIRDvt`3N7&e}V?DjI zaD`0|A>u1IJ84o5Qy3w`9@Jd*Qi5^PRC)MNIm1Y!VU))DW?CzRESoP z6>F}5kP(xpO!81j5y68OyRDcPZ=XqZg`E!05crGgKL*jrq|mtYR5GJ#PiA<9Ee|e6 zXuOL2&jHhg4u-r`msD~~e@jJsTbO%=y${a*?6V((cwwz(S=pWKZ_X}>4*CUXe!$r% zTeEe0g`E#RLC<;{#u1pRaR!UXnxd=BQuP=t?0X2(FbrwgU!@BT75f!-J~+qb6?ypU z#qxZg#$>%_rIWr1dSyEP?S8rAS~{E=nN?1z{9q$wFG%N;Wce(3fA&9zNjgsEW59=us*a_ic;Wl_4!@(_Gb~1o%5H1F2{$&gU)Vb?q z06QLB3|L`89--aQGiFaQJTimMMiqDLVsPPph?mT#5vl}pUVG=UWii1dz5A!l8N>9v z`+0T#?KQSBxX6*_iW7Jt@+Y+p|1dZVHtPL zOMLi(pA9zqe+@qmUT+s??XXjw-MFCNt`t{WKo}UE&A^{QnrOi`X%31kkpGif2I$Z< zqc$KCd!lC}ZUt-@(r&5-9QN8IJbV-^K}`X_y6(e& z32F)`!_{YyBKBut56y$%YwpJ33c4*MTZLgWf8JMYueb{B>I&`>8@^Cy8?R?;g5a26b=^b(vP%b4-{R%pEF~xa`u}r)=igrfu ze^l^OqC`=!0jblopAOn6MOEp7upTF|YFmjgw-dmHv0ke|yvd)3h%jW?Q>ngis@vr; z!xq7U{J6^0z+XSUG+POEBIKE50~17^Jv6%sm~L}(;pR^thd6MZ`Nw))8=>chUWdP8 z21j7fE9kDOdhGpgxCEp@zzHb-rTN*Xf5C%r__s#v>QqWpRSOGU$MA5BTAMuJfe>Jq zlH*rnxX_JnU$^jqga{#|D2I=wqbP>Al7VcT#fFq@Ux!O4>DJHnByL2mlA(PYByCt4 zaexfH8nYt)V(^!PCx0L1BPfvRoVaRDC4j-J5Ej(GA?L-P#+xu^E$VpP zG7aXG11PI1deNKK<@!(<43Na|aL@{mpy41J#%9ALJS@YO&2lX)ES1JaIZW2hD{ zWPcTreV!=sGyGyBO|a?QlZm8yf5deRPtljuQZPdh1HC;Az1<5v>c!4}>&v8A4zg7m z?(!sskjQxacd%+d0A*qf|F$JdF&)EV!I5Xoey37x@DwHrXEH)QC*j&m!_Of|0Lr_y zZB&q3gN==}lv@Sb|A)J^D2)+Ef$;@?YXE-ZPG<}I8qlMPnAac`=+Dz+e+$1A#J$F- zBw=nDnr9M=>NVGZ*#RdN#So@(R4gpRH9M(5z2wUk$sGhofxByCKx6TdZg_VP z8bQw)?^lUM-U8)OKk#hbdL4I6$9Qo++#Tw#0PyOQgtThBu zJQws7&`7ojGxtQR_6kt&e0Z&(UO4L@*IP6M3CAXV~COW1sK#CnbtD7IfC5VM8=M!*xvev_#PuCxVQe!-xhY zYJUTYyDZtWBT>qX>Rf10q9#y|09$0Z#la{wMyRC_&p?X`y9s|?e};{v(zCF?4O04_ zz28_s2%1ul{^649!a)=ZoeT1!m}Zf-!MrG@SkxL`Xv_J4?tG~aXt%uFr~x_`bG1cx z#js{8WU+f94C2mrx>(iQe4$atb1vE>Ubo>48l4KjxRv@`fQ?p9Sj%Z}!}PiEN=dv9 zS!t#1mIOmuGIUvCe+8B1%?L#OT-5dbb{6KDIRby()x4SF*q+%>2F4`klA(ohlCn#5 zEd@r#fTloch25NMR24DwJ{NNT-~Eu2-`gR_Z0B6aXZtW($NO!Iu#zD@a}`wvTT|Cl zqKfHUz|F|dpP+ynwg!l%N*t!DSE_O1M>HvC!fglX=WrG5fBe;_Ei>qCphJh^R*|Sl zq?^L1qhd)s_RO*mVb82PN|Xd)zXwH3%)V^{-32X-PPF<67_>6y8uc_;?^k)T@vqIQ zTZZgPj^{j>I1)_I3$8nNN%|>cLpxc1SOk~s^H3Iaq zp%Fztj)zpSe>)+J0OnOYVQ22NhBa0IctiEOFuuCX`oeYZPSMLp@baZ#+~FVV^ne|3dvvM2|lotopF#`e5ZI#j44 z^wOY02?6a7Kj!mjpFQih<=$i^W}CY7L{8xx)Zw42uD$g1+rtiJw#}FA>|z%WWDAZ1 zI%0k{ii=H0HW(KLJ#{9^yG`GiC}=3?K@KM1Ku=;P*zS_FDW+*8Uz ze=}OQisiTjI!`)lv0i$&L{;Fh0B5z5J4VE3I}s>pg)2Wg9Fs%l7(DJbO8k_xdJ-sZ zDH5=9JTb31B%QenD8|o?#;g+@@gS5T`2_@);mY1M^ZRaw?Pq98#+ z2`W~6uavksIk%giLN6%6`Ke9PW%E&xe;%Rq9Orek$!5C=dY$0WqNYWP1XENDc{;-n zm9wAvUC}=xSE>H=N282H5o3*AA|1sQfhu&t7rRPY;b{K)2M?7#>eDt^2llg{2J7}h&hg6iEwL0bQ$c}bNH=WIoo6qJe?_Yo z_>h~kxLF4N&e-MQHvIc_x>qLcq2Lzh9c7&*C8lSXj-s)dcgJAC_9Pc7Z@Tjx3p}lk z=tuHDcg|r7?Yez|;GJ`vK-;!A5DT1qpoejoVu(6wagqHEazJfF;I{W zzxELJP^-=Cptt2?fZeNjI>b-i1gM6-n7ex0q;Wg}oF`z%;{6PQbf94PAeb!7w;hQ1 zTO%M;qX^{VEo`)Kfl`Naxo}cH&fv$&mXVP_blYy79E<4ooLZiuF(wSXe`O>BD&VMwww$-1aA={f+tya&{v00sY6+AfZ-{BK1?7Q`dru?HV!2Cnwx(9%zjr- z;zou*ASk*mg>US-EWLL?KH@BkE*`sufQt~OWTd#oKM$j~(Nf;)pDSu@c?-s}LdkK{ z=uNb^7S5fY^01IB3$~BZe+y`=-^2^CZK}=G2T)mK(MiDV|6&otEZN6vKYjVO<%q1; zr^6ZS<|Iw2Skd6k3|E(l^>DhCnaFZwVuNSbMr~p*=q$3#AZ62HeE6B%t+|HmgAI%! zP#^TZv)uZJ@5ZrBoKBH_m}&A9Mj$RPM2cay^YhhnsWq?mvDs$Me=-$eBMQOKv#V~U zN>Q=Fu1QPy0J)iro28$wzktF(0viXvpS^(~kQm5!ATt0rdIW9axop-qPGgOVcrdWsN7ii3;tNa25MyK3;SC0*(nUz zmv-`$GvbSn!&RDOfA9hO<}mH-U%JD-t12BPy7}-+kv)e_`5r%69#@q`Jc$y9L51 zI9Q^O_oIk7OqunH$1!Q0jt}!0x(IJ1#au!op-v5!tA$YmMYvCSGR|T_(e1`Ds#XhU zkqe_jOCDR=Iju}+#;o4LK^>$pBJLlPucK(VpBYudgzHs>k>CXWb`%K?C0d099DE~; z1SQEwaR7?Ee+mV-FjOQ3OQ@$VY7`qwLp2r_F_%hp%ndW_|}Y>QN=m?0G+sR-Uc1+7uR&ImR{ z1bPhJkCQie4NoU}boQBpF4k4_mNPQQ@#LSougU95(+7w|`DX z#)!7-e+e7dc%9fx=}8_uCdsFfeCUQlXNGZu4cMs&k&+ndC3y%YYa}OR4UWM}5bpIWZOchE8;`c3^RJhpU2(!uV70v}|bC)?IBc3sS{8=~x1JaHXEYtFU9 ze{QeHgdVyKxgQmo>1K3NuPhXYZL&}nI$2=fce=Xd0=^$@(iZSReYgkq7DWci$u@Yi zIa?YU?J{K-c#%zfcozE6n@KtZX$ly%E~@aNo5;ZgVUmrl$=oQ0T`kI7;9WO?TxkBM zAe|+CIyU3f$PH*yX9lrqbJpGb&HkK1Av*lt{KJX%($QE&se@W6eWSBa2 z?hLDuWL{vaMPzNC$pVZgCa;H2##Z?aMRz=7UdZg>!zw@6dlAV`$`+lBJ~O7p7M|2k z3^rjz%D|q(Sc<|R9xVl1D!M1B3e{`NDX|G7l9pubs4mBNsPcea7?BgT0#Npjf3{b* zRA;5iDj(Q$nV{!lqOKi0WCJ2)HFv#9?ZXlso zs9irg*kzf9nYW*wBR{PN2sLlk*OEZJ_N zj~yp2^k@F+(=hxqBHeW0j}=!wo3mdrhudv(T#5NxbhP5kJWbOiEynY9fle*Uusr9% z#38c+aliA^7zES3$b*s5*+hp1_UL4}uvcPMuqiG&_u|iHk6Y!Xf956!=xVt*Ap3Qg z57~R-%8Ju!_0iGtqd)hg{+qb!isJuR8*Y;x@0acPFNr-#y}?(rxbWZ za+KR@Y=quf6cI}7f4_kWMQ%VIgSQ>zooL(CX~7!9pL4O6 zpr4xu_WlvRZo^xG;<7^_`JH+2Eyg)QUT_-kw?X=fd)5X#f7>=ktrP6A@*oC$J;}qT z)^}Yu9A#b`&w*Z(&$6gt{He#TsES^l4v06U&j$Q1`SRiV>axR--x+rwu08m1&5B=Q zV91B~hwEO%;m0+^F%;)S9Q4QCc!SKisyq9h?{}0G!-sy1ouF2*F?Q@PJnFscpj&j| z8D`O!I*Pmhf2p4Mj|se<#J5QVkT*BBonWuS|85Nx8ichyZHPZ7{v*I|1^zn@6ZtV; z{O;KC1p3Yp64B>FpXtx`JFxmWduO`|U(vny){7b_x zdpf;q6eZF1#^=BO@EdFTHO$z|=MLo*VdMCH`FaL5&lyLG?W^M1gJC zgA7NPLGkUCdO+0R2(kJq7@I8bMjhgN2yogk$9Mf)%=JV{w!0KWmn~a<80fm;Nrq-Z zXld7XfB9f&c{c2K&q)+40qMTP_HJpY)LVjn1Cv|90Vezq-uY+7KpXNFox=;iEU?Fn zRt)5NqWXWo%%gqw++k-_^5=s$S6#b$a~93a*_eYbT?IYm18}7hZ7myM@_IJtWVh?G zE5tOLHU%@(^RYhM$T!pQGX#%qkRPw)o0f75fAQl#*5dxrN;Jilh2N8X3jf_5DU#)Q zzZGhBkE_P&I}9v3KHNs#EkF`eaTy$X%REhdl3J6b7+Zp3(L53s$TUYvcScH zo>*EZ^bpJxKmCWK20tR+HdMl*KutECpxaOdgLfTt*Z-WX=0`(*mLz#sFf%g@ry0#$ zejW=E8Fcp_aEDhkD_U=LuP8j>LcJBr7>l@ z3(_nBe+~Y7?nluhC_g&NWQt}|%Qp0Ke-6c*s4A0x)a^gg!CSx?vOmXS&i{W5QT4+g zqk8Ga5d=lu#Yre;@cCgx~Vg54Af=wmYQk-fKguO&g77p{(H*o@jz*P?m$3g20 z-2hRb)F?)@|PrSEh@-&hV?y0 zsJ}M&UdI5 zyfgUc@QX(Zz``z{(#ssRiXWo<-xWe|3Xw~KiCe{+DO1F z&pafMwZF@|u_rPyof_b{On?V)D_A9)IQ%ztO2$H0{-jphOOJa5csRHVknM1?>E1qU9~tW39Z@fr$SWXJt__|-x5|yY&L(I^{m29ET5T>5x>auEZ7>5v z@4QW+s)^ zojTCgy(u#)ytXTthr_6Rhk(XNl-MrYDc|8GFk|EN+welHm|MrKp9UV9`+fhRr=Y5@z zbo<`D0_m2Gd(+GTcpvYy9pqa-{gkz0ZBs`h)=gDiiO~ngdmTnWH{9%&RTFQFK{(!S zmNNE(USy3O&|^r#6OzQ6e&kv9*a197Ddz)E99{Q(Tl!nESU169elL+=Ywx%!G4{Lp}@4MD;xbxp!q+a2`l&##_e?$ zi$co+D_Xf=dq3+;PG61vtdXRmvEjD#-MAl(OA~gqEP`x&H~2LJ-{b&eOpd&2=Y!TY zUK>xcpZo23l}VV?RhKV zWL(1`?De-tzy5ap^`B;x<_~|fkdaVKj+%#Gn|C=2?2CC(VEXTCcRBH18z16!5W%b1 ze*?KqRVv|SaglGi5`CC z4IL!jLlA-eEZMc~yKTTfGtB0;TfBcDf&yi`4c1`%gFzA$O`|fn0Gx>?)cLY6Bp)LF zmX(Jm928$l1S0Nw?@xj6EQJYsEW@d1!ffp-mVEf4 zq9nij(+>ac4TucKyZh6#l|LKPF%f=F_*bhw;H8!|!}!8;Auc7`T^eMaS9wb0e@u%sp*Zq;FNo2Vmazf05?>;B;R0h|OZ zg8ZAjtuO9eQ0G+URuj2Rw`=}gQSqv|8e-y`=&B}rLn8QzfR_81AQal}oq=fK8}LAI zhNAxlL!q(iXkSG7JLF(qQ5kJ9e@RFIXKWe;e#}-_23g+cq9v6Qy;xsKZKuAv28j@2 zlceo#xL?DJlBAhk9h>Q>7+7ohLwam0V4H2AY8v)ciy&*G)-5ZWD%E1q{P3rUW04ne zys$wpJ!42pTG%L(wuvM)R;JMty~oqiH?HK+-)R|IQln#xBAA20?JE%9jbsDKhubT-y=T|hZP;V5xHT}plhavRca>EkiBEC zUml(jj{k6WddQhbWcH4o{}4Ba2w;$ziL__$I1czUd~C{4;AW7ViDu%yM{-yxvbP~y z6d`L(*$Nv|sngym8{?X_e?=9hqhVWNXDZp+J7s6Mk;|BAYvxv1nM%#}PFWe%&rkK~MN{dTr}PkEV4`SwnEnGHu|zzd^fARe1c6Zam88P%ZgYR;ds!dfxN zia1tA92cNv#BpK&Lt+FG(?7uG(7^8)U~@vsbSl&LXv4k@wi!^}f4z>i=?=%HQ=h&^ zX8MQS9B<&X4ZAs^WI9>ud!%H<5S(NF(me#{gq`U$tM8MYp5ZvJd1c>mnNYdQ(1XZ>@lkIw&=T6V|q>Tmo^D06*}{1kJi#`ONn!Ba!6|FRo{ z?1;P^I>O_Ww?q5=f6kQZnDDtIXCR24QnLJR*(o=LY{wj(a$!hkSb#F-3Fs-d ziHu>VTq@E@&Ovd8XGbJC8d$ZV@@B~nvuZsR&fidKF1TdVy+`d(uW4>mJCZ?=j48+% z6F`@&3`Ecp@*|d?Ww?2s2gTpj=VzA6V(HB(aa_>P^vRlWe~S{&qP(xc8lKIIQb5!YV>&)FQ5^&4R`6T?Y57L*z z_?5#iw6g$(V(Z~`4vR%J>OgI>!UH-2P9BO|_PtXuOBRZ7sbdW0Bq`tf*z_Ph2dhsI zy_UxzO&+0;f7Qx@w4~Avi(ZfC!7^r0%0i^x{IQwI>e_{oz1X}GQ=&-0{K&u^0ePv7@ zUDq{G+>5&ucPJF6Kyi0>DehWya0(ah?(Xic#ogWA-9PT<`}1ZeGnr&EnVjs|vt^yN z#^%}B`cB1+)F(;H9}DkI-xf^;C9}7&)t6!M$Pq%lNq!a&)Ha!jU|`lV>t=d#`$gm8 zv)Es|&FSbbGlVAhUd&W>TWm}>nW5EYao1xE$@7NediwT zzjRR~G9w7oSOtwzjV zkfgE~YBScW1zr?O58Si2o*b3UXz$L$ewsLH9=AK?1eo=7!q7eu)~|P_g;-|w=YD5c z0uL(wwy6i%oUyy5)P(mtY7zeHnq6G;xBAqRudM zh=GNSOCQp+0D33kTB=JU5}y8%PC$D4N8L)c&KNw2#>UIVIHHv5ZI0fU1xfu} zKoQaAo*_(UVjkIF=IpQV$DLSM%rSfy;;2=YnFuH(6m|n0ep=M@ghMs@FF1G27OGfn z42I;eX->iGtZE7g@FCVp)&)7#mps)JV$qmw$3X15KwMeLroJ&$8log*;oc!K2G>yH zuQg{PH7l4f`vVEuv>erX#?B7*iQKI z18LvLGA{hKS&l{Z=mIJq(R zcL!E}Mf1SDV8WqGEPj(Ddi(dsm?u$ct!;;2v>TsOt7sssD1(KL{d;1J`vfT~X5gI? zG?{|Mg%YQQeEq+5haTlasaC8s7HR|Knf;ARW4N&t*Ve zR=5W$+bL7D|89sJFW3}?fHtn)@i!Ax^uY2 zUPChc=%24|R!Oa)Tu{^Hd-&3+GcG(i z_>-)Oe^u%!I5AH>+ddGd$-`37VG)`>@)EkSD7K^_4GKI6f3`c}*Z>;IYCLkpQxR$5 zb=sQIvixpUWJqdU9~r4I0NW(^fE{1tYXN*q*K0x%Jav|`Vl3AL&=0m}H5&iOD&%!E zcoLzeGbOc|D4ckL&E9d6Ge&&myb$|nYnMLdxcXPwNys!pN$0qp87g{T&^@tGM?6*5 zc?7;=rp>#SERz4v7@)}rgsTShnt!+6rCn;A?Zw@eMx(*CDHs2dnajY{`LzT_k6Sa7 zyS+D|vnYW-q~noE17=#doebq;abS&@293o<5OHiQZ0)DjEv9sde}`uE(%LVpZ4h|t zTRUTxjazB84zSMuxuxJ%|g3AM~K!4rbsXbU95?Ks;kQXdE&6oVBzm7t8$*u!jChNU(6$r2s5 zJNwT(>8g3N`+ST-td$B| zfGn%f`Vl(!J9(ksCM|ajRBslOf-i}E3e9S7Yx{|af&kXJfo^RbpO^afKq-2N^~YB2 zJ5PWfgSD(oA3@j0nCYs-Kg2;kUgXCm1W`5d?J<glNp5v4lRX4uQ$mu-C7*1=eDB zm>h>B$bez%S3P$-m}pe3V0HY{z<5#v-v}(@j${x(%|vVl zb#SzR_MjPxBXU1`-Y;0ptUW*8{>U6;B7rdxWt4X{B)6(1GPWDV?X{nc-T3^4n?&~- zFu0-P=d0f<+v>W+ntuF1Yd{fpP!tw>^NeDotpZ}n;^6-#-#RY~LI_J`FluddvfMC^ zIN{Zq{;E=L{;20#d(BfW6bu$MC>SPvsGE}|rOM$nIDeV49WUj}_UF39Egmc3Q>P*S z71pUM}!21@t`&y^eyJ5rsd-JnjtD@;NqvOYB;n(SVO zLl5lw#=`u~&+|&4(jw!7WehcF^v+@%#va=qXa|&hdPI` zgGq93Vd)Z=l5(BHFRZ<2inha(R;tIS`+%^*5PG#868qNeqC@T-&h*yI^hS3X6`x94 zx>MKoxRGU=++3Vg{|sAk$%XCxACLLjR)hi`q)i&MRrB1zz8#ooz?(jgvPZj>F`)3d z?NDUNrF3Pv3v5>ygK8ch*ZkniT}95L4~7vr`W+F8tO|BN_~&@#hart*jXpWJ8 zgDMsN{R1k+$K`@NK@_oREBV;cP0V^*hm6w-o4}K%Haablzy}GMqZ^Bl+ZEU|Saecp z>m1l&iAFqFj`Nn-n@y@Uw0`HzDR8_Jkvlta*FdRJsZ<1O{kE!c7PoeA!cJ`IE*z9Y zJL|^=K_FgGnACVG!FG)>TQ2nq*}Ib}L9)MxW6w zLTPB17_+N{<8yr1jQ?kd*#<+rM!T?OpP(`6lEfBDqee~*{Dt9je$jf>2oza2VPWjS zKb*AGfAKkguv*Ea)YHpzK>mV5d=HY;_FO#vLcjCg%_FU^A5@ejG&MrJnf_5s?OXN| zo+iLk8;C(4cb!DXip2lorhnnuis5;e{y}rtpk9!_TI1%>V40%dZgpt7K5J91Pw_Vs zacMGE8<~~UF|ybAA2e(XA;2y&U|)_qP?58gl<)g7^!LoG!9VDOnV1z6gRe?eud@=+ zz^_^b#T>J1Ugc(p{rq8c@tQd^ zkYN2$DgS<@I;=-EByDl5Y!GF=roRcs&U#=nOyO^J0!6L|F2Sqx004jo!U_wC0JMR- zRHoY9F*nia?rDO1Wxczz>(%@E$xoPHYrD^HRbpQ_UiX6}H(X)#g1g_Gq(kpobl!0> zowLO*LcFHx@DhhHjOZ+-ZyZZi4=5$Lgk>6Yy;WG@Cw6ofOqvhrfKjV&sbPvUv^s1# z%^>byax1#2dvq$OfZ{rC1AE>(_mY42KQGThj9;p*^3}gxRYE~Ws~KVOYgW4Iau@N? zBhRvm4hcG{=C&=x_$+*Z@_Z(32%VL#DsDE7Xsfh}=$_7R6xr^>ZrF2XiSgF)@kg)9 z=xNKQmNi{4A975JGL5b?w=E5N_R2^P73V=-OlXwoL8ay@fNY#~dD(AY$*UYq?$#2m zaL2p-;)gQ^QK3Cns|i#gTuioQ59L_P_p%8W*-h^pq%*Ba&Pxs33YEgs#;|BfQYXpx z+3XV{dgLfY6epkI*mSc;0j01mgBn=r`}AsAmVQ_Q3Q*USlN>sSxCQAWg$As5vW@XK z$l}0FuNu@gAoE=L8{~-;TZ9tQ>ATm&$)8>-W)*@(Y$@^-Lj{RpwR^XA!^G2hIaHO; zUsj8C5NG~;iPSK@V zAiqtDuC$MG2xmzM&E1v4MrLx2SmF%#*Xi}jb&dzj%E)^k6~=PN3*;Uz_-MB=&<#ck zq%D%-8+UcF$9uW^@A3BY5j7KC^<#H$KX0A!c!G~>XTcyj4)RJjwVW*SW?g*{T_D9W zrOSCZ01}xI#9>0>S;(ik+uQYZT(?YXyfK<`!~XcoWt%WwX}|fk>n;c--(Zo)Ik;Aa zY$rAnwLBw5&Ef~GT490-E|ZwNG$+xX zVd*Ebl_~e~4JKqW& zH{Eg-DyD$)GRS{+I4S8ojg^L%52tbCOJ;0Rrt{6T<{zdO!i52Z(i#y8Y(n2tYSKwW zcfez!4NMiH*jbrLIt48PWe3|q`<{#_fMTfvy~Yl1CdjZ3mw}^`MUmOc%?blj3nO++ zJme`n}NNz2UB@#=Vah;*B9|MbE3 zk+g*IcL98hrBN@RxcY}5pQ=P=s*Y*e(Ou{QB3^ta}>6m^mFf2D_}+dKISU(qU+ckY^)rjZh1j_oz_egKi} z?;mk%su9C^JSO(l2E!yb1uDU9fT)qxwM($9+FPMoz~0n{b$#eF{|@iEy3et}<=9Ef z7CcJ{hecw;dJ`T#<>-)kP;q|Eu>Rrgh2_R7vog4cNSfw-b3SUX+gpi?`42o=V{~7` zt(9Y6i{SOixw#e#yBrP=kM~a!+GQlIW+Uf(S-H2r?4B!gLn;Dcce13&Km)*^LEX-V z=yGSDbc=6X-px$Fj~ff7e_g`y^8Rre)Ui?u+1O}P)OqK{4VGChs-h4td3LL;gPUU1 zLC&D(Qc~XY=!!AWxjTZKtMsns4`Yg2JV?N7G&cbY*dDoW=5lo)VR;9BRM5;r&zh1 zw<6a4eU%iJeB!%?j%*}dhrGi5=>W-ZEx=o>;3fWYs3Q0SAYkP4pa@~7T=A0M zROIxubUB+EoszS)%2kaTR^o5PqTkQX)C3=xDzv-ZQ>=+oV(d32JZ35uCXrZIIN(or z$H9&j9S63BMp!?H8A`cpCqurn&_HHytxr@~rN9aFmdKSGKZ9k z%I8ZT(_}_IIE!U%GH=W;u;pRwSL;P-H2;QcD81vaK}zkI4gco36ekWryRW3)m`@H z!~&WcMf?FkTk`T7x2wIy>XKZAjEJVx(J3I~a36c3811OY{jw30_O_d%OrD03S2w&` zEx{C*nj9^$To>Zrus_wfT2;B4f75cPn+A+nq^-;yF}4`_Mfv$w&D){3fxF01km~x~ zTGF^M9Mj66`4pAMap<$!`kZ<6=GpohcHHN+mIwp1l4mO7cp>(Qchc1AOwp3mvhKOv zIx);?%8V(d=wBzf;O*jMA!9la6);Tng3y0Ok3+H8)H&$c%fwl$99nCzBtor;n&%bW z+{_P6i>GDkiDddU=ffwDf6i7n$hlsx0ZKXI;e_F%M869O*-quuv_)7+nY~-N3v|Ah z!aHEdlvqDy_$ZTt=dHGQ1}3h+;kkc=Jeb%E9wVjVh&_78WqChDK3#G`>bt*bS}l5C zY|sV&rI$!&Lh8HaT*)^bpNzU6(={B2fL_k z^MUy*!U|Q-*k2?DXQ|U_INvtOXb-|UMz;V_Mv7mbwKQF?!*}k`bcU%!Jcc7>(FJH( zngBEBgoz#Mxnn@LUNV-I3;D9J5W~+fi5aqgKpD2Gq|kv7XjkZ@?Dl$n+RgbMAIw}@ zi0=DB9&4@)dCa;~RaO3Zd4Bj)0&EytiR@3?sLK|-X7g=Rj&URr9}cmQ`| zkhr_oi8H?c(okX9U*=j(Z)_cRr(zr-@=AwzoKJ3&|||<4@m4Czf)ax zr`R{lCP*aOzTTgRO7U;q50A|ePE=I3L92Hv(I0JaQp}U0f!5<$80s&c$lt;73iZ=* zuNG&FE>iC+B8M5xkYvEx`gZ}n@n-oje}gWXXRpApusmmUGMmxDnj{tPq8(G0DJ}fF z1#{2GP35R>Hx(OMOm^ah2T<5Aj4 z@PkOZ0Zr}cY`EYVSvqHcV5RGsQwJrSaIR`G0o}prt{u?EeI%Si41~RI>D1gG&)h7F z)H}1U8F`7bDp(*dPrp%ThuoJacXn~sCsWT}5J9^)$}Zr0%HTyjFJ;QKTNZxK@s%*? z$?BVw{ZWh@yWv9)Qt-a21GC87Z8QUxH$-{f|bs8vJ!Sr#8MRJaU zHrgV1#PJZ@wYwNKfLIf!BvJQ9x63sobiJMWh9Avhh#-|vwf@EAsK*wZ6|_q=YuJPN z^IXgruf`KD2_wZ)F*=Hg@|to>oTO5A8G$l>)oc>AsYrv0Wnrh&OCUC=&*l}MYN9~B z1;~6HE1GuhEM{KRX>>ez>{yX{Rg5d2)~MF3F9`D8+?PNB%)*}|h@IB@#80-{)XU=w zhY1(|OiQWqnHDiLhp?*VFHQ$(^YW&)@bw7T-wL9Z7%KZsF~}L1&tfRq&f}HP|KJ;f zl9GGwz7l&oQHy#gJS=i@;g#8$+EPN0ds>&mi*Z;R*saaRP_4Nux$L|9#iNNE(QYa< z#p%lJnsMO{tmT1oF(r(jmi(4`a#Gly8BscyIV4Y)bXIAQ#p@s1QpWLC^yK%mtUOrn zM1#p(h&T(y1O;7z|D!Jh-C_ZD8v(aMNV0#7oRj2W8ztI8NW#Tm%g<#m9zz z3azKKC?Owt$Y!RrrNl`G1uXT_Xc80gIKDBe#2>b7uf6g%zx;iXlp(m&NB($Dwm#aCnC;V+b7Qs zZ`JKPo7=m`3*TIM`k9@GhIN70+MNr&cj$?Qrd%xd#*B+w!%jE6r)eT73AqjWJA%8; zovT!)2w|@a;C*_~=`{;^?~3y_(=vAp#J}_o;;%bz>%JkD6ZO8GsDw#{6*ytk{>BH0 z9&B)@DiAdHD{*?aUaYpnlL$hd-fR~;s}#$K__mS;QpdG-tF<<;K`K1R-Zm%l{k`mn z`(~FTO)ZgYms3VHlg&wvVIHu(dIqy4q_dZgZaRz4*qJ&}extcFQQ9&tN7WCKv^-8( zr(!(n-y4N%tptr|R4YV)K<+x?Iy69E{xNbV%+`YH!FsD6UTn#n#R6XD-MGC+iG*OF z|DQb6$RLjsq#%&1lt}ewM0ctEQLiQ0i5Wop$?5rg|C8XRfa2ll%Dmk`jcRU14_2rI zvNbPwsM)|Ur~I}XWHDkPt&7Wvr}$Ug{BjN7H4esyEBb&TKJ6|8O7Q|n*qdCrAFmqInGuj zbDjf#qLB0b*0t4a6;ol#BLGl9AF(vx=Lb+3SZG2;N{AchVe~{*;jt8=3Svx${rdLz z7AHjguP~=#3vpX_du|_y+%;gW3_ISN#Y4_VZ2_gv$mn!hLW5)6xJypk+SDI&=OSJNUstxza{o%p6AYTEY9{tfMi_U>48Xy1+bh#U9dsHGY6@n`eQqaSM6X z?rOjG%2JVmh;DwN>J})7C|)y#q)2be$9Z&{bT0MneBX3C}z~1U`4@q~RSP{gb33qF_1=bC*q`$D?RfXeq)dERgvMaxzqC>vVmy zsS(FGaW0i47Abjb*y3(a@O$CL0_99r#i7mBObljcC4O6@jsw;*Zse70duA-FsWE<+ zD!$&76s!kkUO*FK9zpN^amxL<`_wq%XYXn6U`RuJdSr!j`KOF9sD;*wN9eQhv)-~* zBTvn9{ku9p^-NZ-e87sg$e@fc(y-BEpL=bunmS=b%~Z9T02_uIG>_8P-^F(ZwIFLd z%D|1_Z$DL6Aq&ve8#((&7K@luDsMwtMnaE ztq0$2z^s9m2^;wtJ@B2-EuN}xzM9TL&j~!dD8??!2~Ju}aL$=gNYbF)$$z!ogHSkR z*I+wN@jcNpve0E9WIPEHme_UgnryGor*HipCte|jFbCv5iy-a@VQDjAeRj;y)@!KQ z%BMxh_Fs=|CAOB|J>Qs}U`jfcZ{Ky{jrfT_mTFR3`rPO0K3KJecf7&XRHRpOB^XyWEzZjr^gE*R}CiN`9#J>a^K(3;2Kqw^j6#jl%KXe zry;@%8TJxIS)x*adpkn+wf!}-MWha9(HE>pCh=}+Ue-@e&u zL5mIay8dIzX3U6rg^tTj`#I0)z{8#Eu z8>{-LM$@;$LzaVVc#xuBqOeFLyINE8XV)xAk-J-*4CkF0(fxy{8AS16dgY(OhPeQHr`kbZJ8fdPYSks&KR`|-3N)T^2`)-2TD8Pg~7wjouT-GOg? zQfgLuE^N2xQLShUI84T4x7TOMBrQ*}beCRjz39VVYe9rvI$0MS^o z#OCilqnCzBOV8j%(CIG?M1+>6mc6B++}W{OsLFK0%LN?O3S$dzr4)#RhHB!x zX)2D(lbZJe$kOf7U^qf@?R9yQ0XXP^{kh^k_1;Mj`k#%tnQ4S*cZbn)mh=@r8!KhY zOXl?1l-+~%LZK(UZ6ZI|4sHkiP4Au}JHdm+UmoRz4&KL45EGy`>lDf|m-372i?pF> z+Q55Blw$_2)v{D9sa5>9f#r*?9mVB*@IR|!QrT2@JY7hgZiK(Z^q%3>fpDo-W0{Ll zN`!J^{}!P0_VHxSe9A9Y?_<~UL8y`y+vlD4O|$)XVgU(t`-SCR=F8NSBPROwq758giKmHj%e$(S# z_(w!Pd7aKH&?!-`-F@LT(4f8C0@Bp$wI4YZ7dwK?$%BCmH%avE6a97ZT&^R{@P(8q zA0u?cpwj8!(Xsf-n4VE*6A-A*V>*Su;%X_iO z58xC`?aXb*5tH3XjzT0?`RHgb>r!ZNtv}ltkqjFLo)%{JHpi9&GG#lk)?n}B1aTPC zd!h%+Ni(_bm)>?rrhiQ6y2iacr-H_HN5tl~<4AGXTK1_{)u7Sah&II-uI zZrAzKJwlQ1Hv#;3$93zzOzZ>Ua(v?$VyrXn6D^ETr4tMcEr;K$rjd)9t=M1@m{u~s z`V8CbKgy-~hT8anrD3EpcsMLV#B4??h!$z_I=!)B6FjdY!VOR$zJr`-P z!kFvgx>cpmmb0T{1ON@r5eA1i4)k79>*Vs!`>eX1t4&vng^!6d#KfTO35%l=m)8wd z^WnVyu_{rFffI_v?wKn?iLN8)FLwI@YoEzj>I>0pSodefrMhq<0@Y~vY)^gf4%eH7 zm}{>TwmNac)ZiF^FS04{ z$V>G@^_;UNik>LTV|lhcDz^&9tTa2{7Mk@U{+4aePU^x#)1-O%nF7bjg^IDmLX|vE z&o+8*q50sG<(|iK?j=ZpskcX6`Ttd)a@BrIcR)95b<<}7il9;wc|R&A$Dixh?9C?Y zr~ijIVu73yxnH7uzJw!=*wy_Q*Fc>gG13wu5qis>V{^2O)v(GNarOZE{Q4owfF_iA z4MqS`u^BJT8^X+8gEzCMz#Wa!w(I#oZ*B)Ut>Q#`qCWf`QAkCOmpY+*`zkI_8Ks9D z4=5Eg(r(jG6~I}rrY5ms1~ZM=NPqeE%KK4kSkHS0KUq{gaJArnF>EC9!H&9 zPK-e4SFoa`F8wDWFv7>sDn7{%!nqz}9RR&_-1XwCre!~$_D*BxdVBwVGia=!?N3l) zkU2*!9BxqM9e}eqiszG+5tx?=>bi&7IB+<`{#sQ!c8>wtuaG4Jqsl&cKVwAclIX2@ z?}bW#$IntT`suEaC?;sz@9B`^AXrEQYPgw`App5t)nb0`TRxceQ$Y5A35cfV04xye z*5z?>RGi^ulkQTv78ufzu_!2f`%uV$m~72wSopH zVr6mOd75;Id_O7(jl!1t#!v(F)~cMbTVy%9_v9@-Ri{Ny$_y~6)YuHeC8&rb$iAXO zSg{-hWT74A`-}+57ayhjEE-PB08;LU-ViEsDAB*>R*Yef-^RBIVVQE|`I-6|1qIf% z$k31;=J62|8=cw9lv&|<5FNA zcB$31D!!10_8;L+*Y|W0+Bjoa2AIDhi4>KpQkXzNB-5tKQT1QV@v%hd+X4AFZc!etwNHtpBa|L#uya@6<~+n=yYuc!X$Bc0z$z z)(K?xv~%2~PNOO{gAJz&yvD7^rQ%OK1fhhiN5`V`UD{0>4cKkPeN#YbCy~a1Q=uvO zQ9ve0=OGzg)mky*(LhBN60Fk@8lOq|+u{#?2*}386+leg;OiHP2@q*)(*o)$QmnP? zzlM6?hf02|A0bNle@+(Kbm{9WBw6gU|267r6G0OeE@%}Tlzij@3yX?ti#};9*Uuv_ zZJPI7Ub?Bg?`EbJw|6zLVXpb2fN-g#D{UyzxGUONY{Li$zw$1iqjWHOddhTZw84a+ zZ0n)qS@7-XN<%iib50R648a+u?!D|&D7t?*jt#b3_ik~}YaRjRy?Vrbe5w{?HbvXw`q(e-W4BEW( z`lBFB=p;9z{2b+ZeBiyHBYF*NyxnEOB6@>~@V+yBKeSt71)Ml9Hu)VcEqQOGWZw<9 zrj*omcalFYM`}#pdzn6;%aQT)BjbsJ3aGw31QEQ2iUE2pjy-{&7$Z9NeZp3ooEmRL z9X+{s&(~zdtbni&kB5nf_i~=h_oeE$3hao%G38ZT8{4WI^N%%I7R2=68nm;VOhVw| ziX+V9&?4LQNR&Eg+iriDBMzJs4AKm1jaNWE<1hgM_1~BQb;fxy7WJ}4KtKhj9R4QvtLPe}NbJ>P z&UMW85R7t=iqO@+Z&=XTx=K!Jk)lbC&*Dg>8QwE5D>~X$*2^E&`}3CkS!`wQ*QUCS zCyWE{rY_A^V}b9)QTX$ux>6botBzup>Nm>_w9%GPug46ksUuOSczq?L=F~{v37Xb` z-M>W!I-21Hp;Euh0)(R#tP0v!ZgwDEG*KtgeA?wMJe=rviC0N}!69OPEwvS(JtC3gIn0meYnwpM_ z^|-SS9zkvozpD+fOC6IR#9l#kbh5pGZOJo9Pp@oGmmYil{`3-%=B; zGu?k8(8}YE#D2fJw0)!A!6yGnXs+s*9~$m4v3GVwqf z)(fQF`&pU_lE~84?`*#cw7uHC~qtcS>+hBM)xT?btgfT{ftq7~i)2^sWWYj$}^wv7<3B z?rt6?#$6})xt#z+A=4_4!p^Hlx0eGHUcU5a7U2D2s;YXD?`rmg`7Wk7@`v`_zvrWl zxOmMwHU!%}(BnAK>V)a`9{6V;?PtzL3)G-{)us9!)710w>5|JVRWMZhfRL1B;K%om zG%}-}8M*XZzl)t-Tw37NjSny4Bl~$fiOb*(%f81vy~-UYF2Lb~twAX|u0nA!_rPI) zEBVj;N6NFxM6~-A#8L2@%WPxj*3vI>)miN=1PBzA^s8^?*{N=0P zy7|tkN2}|x&=h|;fzzz*>dFe;>rb4!7um%wL7lgGe^fy4avGwI;eFjL8soeR1 zI|kwgsGonnITgLj5WaQJwcfkC+mv~~{Vcu3^|I$`J1=gWfBX72M8u|DsCDCk!oLCi zp~bB0oGp7c@WS#=r^{QIr>SVIt9aJImAJ%AVEy7VR5y{VN{F1y&XbkE3sw;C6d!Fq zRJRm|@~=)nlLWAKA+iJZt9R8O^f(#6JXfgD)KHr>@-)J@axY%8*p(MBYe|n@AHLltvm`j*72-v{u{qUaaeS94 zb;?%zse`Fi9^~aYRg;p8IM_jt`ufi7(ZkrByqY$++6LI_+jz%#Pzd|aB3g|zS*<4` zra~zP3XJ8MBp2a|_|HmPK(l>G85%Vk^Aos9yD#G{9-E+Y-+Cb2Xm-w(V4JBiE@Nl8 zLT{A}#0kRF2JZvk2D6t0U9+K0x7RsEev9~K6L&g2ARd$OZGF8eT9`>aB=G*MP2VGn zQ~s3-;{&M5bf$tEO5RP2-9@w;$FNI?PX!;xg&BXz@nzLTBUs!uai~?^m$89n-|2$> zgd9kW4V8eJ71EUGnHs8NVPToM;kZL~)9PgCWqUrz8Mkslu@^Fv{daLW!a@>Q9t0gw zx~^FE8JMMeW-M~|F)uUC3@Pt@kTDoiv1=EP?h zYIc?Qem;~IOF`6#xC*^$xj%8$a~s$kpK0HqF`T>`0&!37?;1v zC;`D7nWse`J>lrV041{gTUyC9*E*R94qtrQz$3pAqW?AIUI_g#JToGWC=o8SE;MXV zbR;*Vk)x@Uv)?h~YWJTcP(9qa{%~z*z4?k5yld2*&yJNJ4^C1tjjViH7H2ey$NB&) zv}I9|Oczr?=UY>zG%^gN|8_t$3S&Q9D1eSZwTWy8<0|EdgG9BINe~%H|3E+I}*Dfr_rZP+O(Zi8k-^7M^gfdFUIT4|6I3m9TI=;8T|bd&KN*onAM|3Sr6;huWh7X@})5dWf5C8h{7?1LN>-71}o^ zmjK1?RI`WJ7Z-KI_Isr1W7oO$g%o)2msh!?py`2|}%Ci?udS$2cH0B0`{PaY2 zj22OSobQ>+Euvv?Fc|)!!Hf8jp@S=FCGKDt$Q>wO!i)Un!OtoRjXnucDVf*wZj@)S zv+Rb0-hUV3x?r&UDeNfu)1mcvcKLszQ%^WV@c8_q|1$t_U-ee;b@9t-H>_fi4*b2q zgxh9fd$$+!U-@3{`}%12G!vC{ht_#&Q^lEXCW;Kc$sGgF$YAH@fg0 zZW!Ioqzk||!g4ns?IMP0i!pzXLcaM!v z>p!En-_KnfagJ3>LJ(?Bk(K3Jc1SJ4;sWYn10CAcY7_cHf1l!`zo?CpXBMcmm@Ss` zS0;&%2y2>w+IZq(U?@<6#!OnsVaR-=nRhd|;lm(Be}OmyF(eiPeo0!04WrV!7z=1o z19|e|Lnk(jnqm#Q;@$6oZzGeZzHd@smf6k$?f9o_Q6Ymxx$Jj>oQ)THqr6vs|4xE#Y`7=4f%rzO#to zZWLY@p-w$SVa4GSKVA=HewmU|YS_33Slvn(sM?%^olXA?7FW2I(Akzq8iCJscL%!$ zDo*0xz4Zuo-ym>E@;EoRSQaxi)i>3*wP7bW*Ee`rRttnnA(Z@Hu*GQB?j2n764azY0OAME`|pMICb+%T0JB`P+(njZ zqwm;$AZFI@L|Af4-vT#NS~iy*2aT3P>*6Z6&OO~iPptX0S6~0@V;il(JRNzh+aPng zXLd8{IQWziR51ZuFuUtMmLdZPPWCOCj4favF$jD0~ExC8m`#CsW*(>U$+VByZO(yJlk zQk?#sh5Se`EX{pa2K>1M0c-|}DL(m86kzBB5)U~wkh}mTh*uO#Kq7F^Y zg^*TH5X~q|y~g!ku7wn|9?tO&CpmOt8osEM9t(&KWb!$_GRpVt;vHr7jxoX-ogqPtfb5_fB0F*VyF@+I@X~n&*X2AV_r&0^ zB0lCudHv6x+2#4e;gz?%u-03LGjei!^oqzJ3{0}{;HufQEt|=%eYSn}@2`}0*@9Dj zyw!jrBOB#U8^dj~GL-p23Ult0mAZ&zvout0lN$fkyojY{$DYOPe`jsdBKwj;|JZhh z;s;)kA8yEv9r8n(r;{A}!yE2arOYGnkz#_Dc9Cq@Olqv%K{Uu%6%v0lllz!-7+9|i z)n-TB#6BhVI4pYri*`C5AyY!!rn4up;AbH5NN=|fuE)C7-RY0Bq1uSrC-hT&G>@HL z#^8mb7al*v2pfg*w&%7rSY|wqJPRK0mc6~H`RjH&gu;~thKckqB{X9 z>V^6-sz}PmZ{G3Bl}dV1=J~J$#>Y z>NR9j@G^B^nsHyi7~B#VZAf)ivy7eecK>>&kg_Ms zwZ+1<9c~h>5Vh!NXGsACF%Nqb2i-%)o z$vc8tau7;I{G{2Z|Hc-3%c?LFTzu`0$k=^k;U2>S6J5nrN&N!$#izD3B44E*QV`7h ztIOB~ESNrS`T&?dhCY}b(ZXZS=M6Fmlkz~g5`ZEPfOk^*ZDiUC-6H0q8^tkeQt74@ zRuTuLdY2aRORd)|7KDSqxa4qdz;; zeX7BvyjAT5^ugK5?miVGIydzQx^PIyci@b52)cfOeR)j8YSIoX>|6G!?~W@>Lgqy5 z3Zm3U>{{`5I`U>kd@%$okYnVhcI(D@Xmc92b{ga>FwFk<;?vzz2W%vRI@~-3H-m~N zMpcZenC)rm1f6(ziu85XhI+~{h(rQ%h%lfT9x8M>MA zSXEjV>3Y_r^H7D=14@lI+l2$~R$#IN{Go3ekndgZqnAj{uBmJ<__b8<3Hinb{~*F7;Ob$7z^VknK|84-M-xc7!oG=seUdYd`+cyw!7q z{R8L5^S3rpXa3Y-oJfa~4nN3y<4?_ZNfyz~a6I1!5q#gw8qS}a^eGir;I%&7wUJCl zQ5<$NQ*QNt|2x$ReG-wR zCmd&R1WDmNSPhaWdA}w>o3cREtpY1(rYtve0R}DB$HQPIV6_IGFkRAg8Qo5Vt>2aC zM!i(+Et%^V!)6gmM1xGQVX;t?d+UyzB;PyxF%r)fyHOHn!roC8Em1VAbcus?p{LjyuQtBTP&Y5=d!e z7vGTpvOTwVN!U@lRONfpzyUyH;rXi*AGjaAYUSg2Q*bivw`ev@21cRvTl{;aYktQB zC`fGI^)AoIe9dunNimqlPLNOx#Bcdg3)`d4!~1*4P0$>X`N}r+kDZ@}Mk^;w0G%QZji)R5pXWK`Q%~BJJ~J@Ix|N zO*En~u0cryUy@1L_~i(1nBZ3 zt~G5*a~n7Ma*{oJhvJ-)67j9>ebP{W z>R5A>Zsk1N>C(F#E=w4RQUQ(6+f0*gONUeP@NgBywMqZCqqAdz!14c4^%h`NbkE~B z-CfcpagpxsymUw@N=iwCG%VfS-6;)9DBaykw{)XO<9~U5-_QU1W1hWt_p;BPbLPyM zIy1BIk;S{2Fp>U!ohEq(wR%Xk^N+u+NTmZ+{7nW;mQn#CKk$3d1SQ6vEz+Mry$|EK zd@Sz;5@=Ux(J zX#zZbMAhesFeS+5g+m4PyiKO#h!g$=?!MK2M!EKPMQQO8QO54VmL@!E(;_X`Nbfz{ zYQAb$e1454#ly+N*_A=8jsZa;7-{Xo)rjIGimL0Zo5=HtODo4GPj6t?A_$bq3(x-t zHs&XKiP713;?iKE(D9@JJnpCh&V}Tm>I4_3SB$VG`fshf1vujcFfzeDC}2QApbMc( ziM({8=8Pj|!AyQVkABd&HVPuO9s6#LH#`9f;6iPw&+A2RmCskIDI&M65v$4 zWDJHyv@xNsQxo>`@(NxTNW_=T@-oWn{n%-@uo~>tQrkAD6|G z#v4I55CC*iWNf?0GS8a_%T!1&)~5xbjtS#XAx6iet$F0|DZy~1QECtYPhcKbtzP^g z;X9O$lZ{I;5n|%;q6!>uHT!-(Vi;_1eU^Q>$|f$i&r7lZVu7O#!>T-oW1=sT7PD^O z;OAE!d`^c3YHAxUO$8`%czvz=v2~fwI)L(tkEbUb28O@iAz^WYugL+7PMcuzI`7dO zC8G3gAtuzEiDrm##0o5o-0Oy>-*;)@!-qVa;(Oyji229LT&nT~ndxXvDSR)C2@Izn zF(qdU2AnJgH4+Yd*c30+7Ed-x&}0;s8#&DQRcA%4JceYHPojHo(LP!fF3>~EkdNd~ z&9LETl~H7sFiaQO!FdSZTff=XQ^AfEMib`WgVXyLinHe7g+}2oFPiE0 z(~_B4{ZHafloRFBe~i!>LW3cmFD%n#VU5WZkvb_#gq7X=z#|QGeT+)yxAs*EYXHN@ z>sS-nUECbFCpaJwhtRrxr?^FaAdoW=7IA~P!w&gWu@Lo*mZ<+Xk42KnaudPSP&LBV0fSxc;k!Gc7TX)Ty9N_g0A!-ACB z$to8-P2Gb@sQ4o3C8TATBNCe8tkI|bKQOyMd6A@vMYPt=0}1&T`fcj?Gg#%iivy<> z==wk5yaYI3L9Fu4#+ea^qeeXt|B+Maxjg|aa_ID|NuSiGrBDgDU6Y zfQ<<^R9uhd@$%BQ;`(&{)z?o2-v=~7a{N0 z=pabR*S%PZzbVsAsos4gE_ncy*&k#HdO!y29LW&!KS08h#_y@O#{s$IUr@@y7jlbn zJrddHh+V6iRXR4WI7dp@!sq03jzUaKx6DbRUgXeHCMS5#>-QhVMja-^bV>A-#}gx2 z6F;d{FNlS+gs?DdNx?@9#rHw-fcywft*CU9Q35aN8L@wa7`Gxba>S6(TN%#3 z5J&vBPI(>CJR%&{BniL;S^i(BJ+^PBhl8Xf;?hWfx6b4kUb0t(p7;>EEO$|(DEV)q z-`dA|aWlS<22>tC?q03S`a|75uEg9{i_hlH-_*}w2phTrvrQdGFGbc^$sc}iyn&_r zE1)Gz1k%e?BM{L(sRi_k9UmPZ6Z%p`-TIh=oy905E@YYPO=Ajqw?;=Nr-YC|%-x6a z;%t4M-?N1HCS?^0n}OK}byUE3PWjJx3O(>33^jv2#OQfxD36g4hIQ}r@O|l+5;+1|#9&`#DOQD42w3@X&G6aeA8^ z1H8-stHK(pFj!EX_AY37d2nXhl=A> zz7;d8eQ!d#wB^Qp33{RjX}XJfm@q@91faGF{ZLXytE^r+25j~`PzEaZwxF2&1v0{3 zq<NOP+dMErk)RQKyk!HsX)_oI(GDbN=L>~#J9e#~w z{hgfsyNnE`YpiR3-vJ!#l5$QJ%!e2_R&C<5Y_lI2?b7Ysm9e2DwxgDbMLOy^eL(0? z$O(W(Gxz+P{?swy{As6Kl7-4gIe+lP%<+uknk~@Bp!qcJG|S8W>SQG5q{XXA3rh%X z@$^4(K)U0aPd!0fv{>^_$&hTK>(S^PbW1x`KP?+KY47n4^$fjg#U0VNo{{=10TmF!xf?4lPm)VwgRdr`~@47JTS>R?Rk4vbC;x0>e1B0WOki~u$ z;wtByUfvgk)^{*<`Vrwd5wn#(DfjDpNv_M_z*5=mr0Sk z(^^cpz4tQkY{PLA*c|?JdTYGb|Iy6@_mly@M(oiNTk1S>>oV&wX9-PFwWg_Z=>uxh z38EvZ)kA@%P1Y-2*U#^=UoD87=q@`?wK$JvitX&mXBCc1X@Kv%l7`N>e0xS6S;c4) zhd2ml23wC4&hi`4_}xMRPAA-u6j2Yn9t;Z%Q4K87vMYoL20-tMK>Up32OicmCEuiA zh)_USM-u@*Th8yOX|9KBB?LkN}AIES5a)_80;X0}z|xxM@6t)$>NpSdjF7 zOf^Aif~3Ooc%tm_TWFQU%#09g;q?4F0?r9b3eXH#=9xPQN0-d5h@E7`yg?sMAhS%o zNBj6Ih+VmFR9PKYiC&dgIf6b{7LCr>vk9sMxapDrpaj%3(BM;XbZc@)l#FkRh5ALa!J3G$J zFgO1UvnwD(ON3~&e*R2o$#$aNeRw?Nnbf-5OR0K97WV=T7IhFLh^QlvuLL>iM*K|W zz<&G-Ks`sXKWS|6y_Q_v(-UEcV4fNX&_P5%FPBKqUmdL*-11`)A>zqIQ|z%pm#jtM zF7AW{@2jVL?I&wKn#uD3&myzpD!|f7h_Pzc#RO6;?b@5TC>uNkW=mAbnmqcT6dW{~ zJ;HS~b3JNZbtGf8!6W71f8`kP%HTDS;VRebWM3JxpurIh zM_4{1`ezZsR>J5!k-7+T!iuC(@|aO_*|+b%?E`A5e7=;)%!O2J?$sE?=*ITg;T5$d_P509+(m+ZhbWU>2ZQ-v2@r%!*-*B#4Y*k|S*ap4vEFzHHq} zDyCUBhCt7M+@t#4j-W+fKhEDj0Oj0@?yq0jb8Xxs`TX_p$LWB;7x5fm&FJ@y=;v3u zjIMq4k72HdZ?r3wDyBz=%tqa`_;-E~btm8aZ0bDh_jq7??~3#Z^@dws{K#VZV1QzP z!a`GLJ%;-><~0V}t2-dGePh*|x#kg_-?!s|+tKe}_a*AYIi-F56#hH%HBJ4mC^TMz zG+y&M&B(=^c+HdsvCLSaiOg6ZQ#GbAKO%n%JkXd+l)gM;w0F&BDwaBTV=k6b42Be$ z=i63~RXsy*;VbT-Q`h_$`;w}Pis@IK5$^*OYGv0GYD#PnB(Vd`zxO=j#D1&A*76dS zE|vTV%x9F-Ro<-xWpZUY;e&4}OgHsgB50JiFveP-bjw0{2o<(lE|;~SS^4Qgv{Tp+ z7a6yh(;ON1hAi`KOUy=+Xa0V&-a#;jg7F0FGm8@PQiCi8Qd?qoc-G{KiFWs>SgLXI zj-{Cv)UEwjZh*~we!teN@B{q*m1i~>B@~gISQkfjP~a7@a#WL*uI_rj`|Y~7u)K6? zbf({ za|F;``1tudY^~lB^~=H2geUfP&6RAucXAgJg3jCtBLW*jZc6}FET+|MRS~w&y2a}8 ziqIFAd#zXH7C!`eCG36wyw|xjzkqn~2z$5ycOC?9=973bN{S>%R}@KQ4-g|V;APiR z?hi@;mr)w`}j9&261oXvphzQA{gE)Iw5{B=WL;!fqNazh1puAsf1?U zfXSq%u7xn4f{}%bb1&eHlzVi@ak^DU^F1Qayqvn)@T%b>uy1k>(r*6Vz13kMa1OL@yWkBXqe8h8~ky{IP2!Z4sVP-DO*d z-Wfa#ro z*(L!08{PkBck$yF<*GT1_w7uEg4FO zSxOBf1Jgr7h+=eTv(Bo7(-IG>c@$?kL+cMfr-Ljgjr|v;?2Hgu@n#9jn2DpO_TmRE zVuLE-5GWBG;6(8VsA{QT@GtVBVDbG>OGLj9qPAEifU$6`4xj@(QxBfr8Bfwl77xKO>$0D5~jH)hy8mizh;>%AD*B5PYlVtqlqq1 znc`!&edf+QZX^Ka+?@4eHB)%@lvZ}Z+ceK?Y;}d&G^)d3`yuzQ7=pH!r0RNCJFz$O zS6CDmKX>ZqWYm;?SUA|tZIf6M$atUO718qo)r6n6a1!K?$&MwWTw$7Ig>d31;;>+l zx!Aai;7vPW-JUhVJI)g=!S2EA8v)3=CY$MKk;l$!a5chS84AdG@XFz@8PS`u8i7^? z~Ami0OTZeIg5r83w0iW1^vu~vfLuRC4_8m4cgJ19!Dt7_#H$O?d zK_uF^RFdb}R@O#ur{#PiZMu32;HUOsmu94U-Qcqt>t!7UlN17ZwUxgZW#o5LMk1oCvQkTB+$1#}6NN}S4= zf*9B!4y4?Tpg8Z&%3z5gBPpH{MoukSsUM`0)E9Y@3hus4rt8JMN>E{>cNjP_Vmy>| zC@?bSbSRhEpuC@1vjQprtsd>u_ztdP;_@p;S8Au0H}8|U=L0xDxSlg)ueP0RdmoX! zZRu!t-VJI%eqEjlI>UPI3!{g6kkKz{0g*2n9fg~>O+8;fSUQ#D&gmN3ZE3Canr1AN zx}5tT@EbmKZ)`pnHMmhg|C5|3y>e1E*b|%ZTk9ix^KAxa_MDCT6}pJ+%8~9nHTT#XWM;t9Eq2O&0PcE-Gfd@Od5x zMr6GJUs@>|oP!ifmc&0WSR+u!{sncT97P#hDkY3Z6b0@h-Y;s0pUyucRg0JJm+u!6 zCR=V0m+#emA>v7fP7K?dyPFeteQL;XQMs$qNLbs}e(2A{pLIyaGCvc?L`k>YHQRyV zMsB_;Kj*ekKWK|JRu41AS%a|*xbU}p1%yQSfdG@ik(Y_f4mXYP7NN8EJ=D;*k=lk& ztw9&oqA+SVCkN>TMdi!xjoL0dxpf2wDab*gh7|R`U5*>gZPMR|QSoD-YlTnam|{>S z5OOrGKhgg#jh2x&+l6N3DTrC-LahSB5XV6G{B0+K5gdnPE{fNS#-=@hv~6pF`u9_) zVEa*7;zPaGxp&jq`PtT2DW<*XTi=bm^_yTaM3HRJ2chco;vkF_nSwB}t*x#5G*F{s zA_uKRMP0OOF}*6B`BVLlTQU(X8tt&FY*K-z1X;D`$bGUcN=tUAw!zX`-StCOTGp z@fS~XFxQScCuWxWnyQ{%Alm8B8H5@>V>lo{v#x?^b7j~lD^60FEX1B0)M~G&l8{71>>ELok5r}4}+%>|Cw`6 zu_+vM#BD%5XO?RR-|So6DB|!>V^0mvm?|{DrivvZT5=XuPmp)DYWZLU&|(DWA;tmN zwP*?{#&u{$go7>GFm%QebF@`Rvow~xI9VA@sB}9GZObK9#AbB>e)RKPeB};FCT|x7l&uaM!b223}EnK%Pe)r+_yU9WZG^-Cu*d6hPT?jwsq7E+Y;|-a#G82He{9T{@YTj$Ht-t?0oZkXl z%k*7(Nexkh`kcY35x8@TLb;uPpK$qOVT`Pc>-ww5vmoh*DV1NsJLX6uW*LCe|jViV%}B8dm)Zp$6)q;Q?3NXh*D`;ic!Na6|2 zrzxOOoEblNR~HS;uEROOY;rA7+O+$zgMVVz%by_pCPBMQ(@yM@>L*nQ)ibJBjL!^_ zT>T1j(QHKf1H*l-=_1W+mJe9!+irADJbt`gZH543pM)`9 zuADm`Wx6y48Twt;xvA#+9|pdW&x7~E_l8zN|M^T6-E4ZHIK(2IYyKjQt1mPxCTLa| zFCw38iu_@~fBUJl!`H|DlOY$^zws46oSxz<`q_8MEkp)HobT->-VCT+vz~ov*!9$@ zOkvhJ;Zyk|a*{j&aJycG_$ogMhplD1k-3fdq7?Q^L{!(i30BnaMF?LzjuGx=1tffv za|~f?1qW*)e@eawX3j3hX8a$~VQb9&=KzKr`AcU-Z0A<_G$GG~jeaJs_mEW3_GCa0 zbbxl3FdDzJ^JuK(Ksvr0&r9#gw8vaD<97E|uA507jRs;Q$BxR`5^RLBziv%M-?ARY zeNwI|;*%g0zomEnD4_ezlR>BY1$Xre^3vs(%P-?T-mf#+z2JrtKC0j67vQ7IV5-C) z#+GL*L?}cozf4acDEECAUshG(v+df>6G8i#9YXkwknk1T$0Ng+JXtdiF?lE|rn(h2 z8U5GwO~e~Oz&Y*(@=f5qF z!g2BT?^CrTe~UuVwP&uMliN;$_6su^OTND>e4xJgj9+Udzacz z#(o-*{8p0;{9`x_m(F-&;$_n`{0oE&ncut3w%Acc;` z3bFrMj?M#{@uVq~<<`pILqi_wfq!mxrXpF@tS$6K*T zK;}Xt-gfL%h{-N9BG5n2*G3BKHg}~)OQsC05j7)lHVKZR#V?rjmA(U_X^#0*zfkWi zKC0mSE{vrV&l2=)dgj4LTK%QxKG`sE=+j@8qTlcNGPnXs@*0uN<`-lY`fB5Tm3qzc9GGYql}h(b#%ZmAHfu!`o1XK+hYNktd8vl;hor{+rpuU*-fr0YRJK?_ zK3??zJ}OgFCc^K2ql6$4A2J;-^kz9J0f=z9e#xmdJctoh5>(2Wkua6?bn;Gu-ZT_O zWNbZ@D2HK08C9)EiHVj|VkXaOlE;#i2Qvdn#WWB`)PC|)*3t98660b5whfN7X-FF; zGrf*txi(g160IhJj-sN=O`WFZj?qX{-ax7cW5Dem7LlFCDd;g=Cc1QO_%;YYO^IZM z!WN&j+0!8GKLub{V`wR4SWTZTO=xhboZ9pIaK)F(*@a~oF>iOFVcQqy%ndv%;ER)< zB?kLdnAdNlh@_>do`^|CtlR<;L21{_Xv1yS%(@jxUg!SVC;!{b`z3=^5c8x2EXzsQ z%}jmfWXn(8`w>f<4WwmB#H&tkNIlBLi)VGFF}*87V#w*7NptV+#eX`9O66gi1|OL- z0IL>Qntpqu8``K5k?>>h?&8_z^Ja8=+gWbKTlXNo+LTBaxp9J z{Ihd=tL`R7@o}Vb#t|9*bn(zbj|ov%aNUtpH$!Xxe$rqms2VO-ato zlMn0&2(1S7An^@wCgEi?ZXnL?)S?Kj=2?Y^eHkt4Rj`UWQQ$mI6iS-NS&N=c7}@xs zwhuXp-CO#dw;{BWvF3G6!t&?!q+`K#&`I=_sdqd3>K`pPfspz}0Kb>`k+d4Eq{FGD zegCrE1biB*5-_5Zo$#ESSP%9 zQ8y0D2%Ggw#bYlH@$g?zK z+iRZzH@g)(x_L{(v8oH+Yw3sla^F18;ic^B@He&7Ut7CjXsRy$f)G2|$TPa4{JDOVaP}>$k@UGWrATE0fH(Nt&sa z)m}^%$}rN(suzG?;20jjF$km5X^1ln85I*GklsVhSAIRZ&TV{qep!>7ZJb>yjG2R^ zmUs)(GXt_4cTy1*MMb~Ta6sq{cs@2e+Nq~#nZb$8_RrexQAAZatlMRMKK)!r(ef2T zqqwFjcNn6%`>g=a$VB%P@xDRhh_FfXNmX-!O`M zp-c~oe~C0{FV8Az4>C2yi=eV3L>E{xRAd#Y@31?L3T){)diLYJWn#vv#TP0)p+Iw;A z6wZ;QBez0}uIO@`<#pE_itGVv62LI|Rq)8k>bl))@sW zDxfq1N;L8l6Y%n^z;wb4h9NoV^9?>`m&)Jf_Ao5bZLrr6rV?ASR1M`Gc~qs$g^ibB zMEdr<$JEn=Yi*P5fRD<`=E*5-@_(A)a%>JnAzUW719^W{Ma4V`#(jr;--I$MENz=4 zF0MfFp$h!~G^Hgl64Pq8Y1rg@>_#)tFY0U5KcNkVVz#vVzJ21-r4|2i=^kW|Aw@eT z)$$-^o5^_;En%jlM594i#*%Ky*%TE>i+K!^njwxFc4WNk1--JU&>mSR6J|mR?(K-C zeTarh0fshB#o@jir)sf}?!sTX@bTOnZSu zLZj(U8{DiepkO<~{>^`JvHBhh+!nYAdgywTDMC`tb=e_tF69&tzG2doB>AECqzXtr z0@Og9_+aj&S3(;qUMvw1Me>-2Z{F4ksacWY-;+^G9H~t0(a-+VtW%N3{<8e+w9s!FvM0WNr(^t{56e~KVB9`k%RroND6Z02$>taP^GpZtA8 zSC_u46;;8#GB;~```DZOQS5iVd*3zSgT>JRf=9@`#&zHw>sgxaL3txFcM8uyv3OPy z5@O`44ARWt7@q)Cwg?5KxIC5K6iTApaLF>>?_T&mJnFs+`r^k>9~3~l>48QheyYK7 zSf_f@eV;Kh{ZK1#g}oVxDH?mJIcSKa^fnHBWWPwWgE+`|u}_e%3eQqu6(u(&;v~8r z)_om1SV^Fm!x&a>xb+Rs7|ZqT;a{`OJJIlFZ_yFP(>f$bK^C04QqZ%CJXjdm7(`qc zxDt{~3PkoWuDpbRdd+pf*~h0$I2TKs?GOxI>jY~KP`(KYC>CkX1%(vIYyWBFsqNVC zqHBc)4TRDo`31EDc#KQ@c-lN)P*PIOVjm!12HqM!AA4DWSaEE7O;>TeU^l2tdR=tx zN$C^bvZvG=aTU=c>gMbIpwR)ARfRX)=!-a91F%lhGKQ2%;kn=|j!6_v$Ft=)<4p=) z{!-@Dkcj{T)@};H1HUyYAQ=^dj?huOelf?t2rrL&IhInYaKOLo0TcrNq9yQdsFguq zj^^BwM8P^l5Q&i~2#=9TRWqvyM{&b*@He}X&e9egublxypNvKj-ZLIKO%k9S7DVX( z9V1(JPz~&IETOl9_>6V$`8-Kr zGyxeCpQcUGyh2^P$@4zBVF}G^x}wl{9nF4@x zo)Wa;PdL+3X_2pJ5o=VE@zQ@qM8A|X&pSfCECdl9TTeCn@9_@A^gD6fA3;_{JLQG* z3QY7w^Y16#di`G1QZyrFDwg@ZIFq8l6kjdFz5k=@JMuJ2laSPdL;T~vWhcNYDM@%t z^qPvJ-QPkYXN}lDXaNs)!2@y+hnEak{r1t7v;Sl|G{pxtE08Fd9ukF>RVZC+wj;gE2)LDtmkyM~4PNJ} z=*bC_R!4m4;A+bgLdgysPp|Qm+C{kK&v%{_6twae%q!RT2ak2_7&+Gp&S%XN zU}gq_R}3E+Y)UPDmAvE&eTqCY!}`gvqcWPA#?J}1$YH;;+zPddna&Ebc=nS4eJZ_m z=%XluJy%8W*uIVGGpxpitno@BV%lvnxzB_2VMi)|yFs-rHtdsh2f32mfm~^v0Izw@ z;Z7Nx`GXS#D>L=@>+DQcdcTB!z&~X8u7c+L^h5Xde7>JExASZNob-$TG=Wj~2soa$ z)wz|A-xgUB^S=tOCVUnK%YY<%eig)Ud%W#HJsqaIv-1SL?tAqvq*GGNj5=T6n}PA6 zpF8kb$*3@-2fQ#&_n3eLA@84*anHU^mE^>*3y;8F_Tf0V%0ByFvIXO9-(S`7Pm%9as)a8#@oaY< z5z=RlGTA+!2xqPJ6j7mx`4OXo1kuJR(-nZ=;z#!m@mJJLB{(LA%Y?sbAKEi;Eg*vP z{xl6vC8pgw2-w#CPMte4W=O4>ae}7RJgyM+3~tKSHpqpq=AZ5jJ*%dNOzNWvcatsj zQ8x^2CWt} zMVz4j)2+8>L8S=Iq0acbCHfh-2)F?#l0no` zIDI9SD6|Ni_6WFM8zn$gW>jZa3lkkL#|M0_fmxLjyUk^9`0Eg7En<$}fTzgrT;G?u_eB1UsX$HUvBCP9;09 zvogs9jEG9eF8S7%dt0nT#?6({`^2788K4vdnZ7d?LYOiGkj4j91nRfvxsr|&G1bO zJXh`QiTserCSqF8RxGIKoCNID+DYvcnOkOMChbr=vnW{rQbdE~OVjBsRw-=A(n0@H zN;wH>2+BWKBwwr$BzwPxyWw+%x^bWVjb?FPdST3CkX&=0{Gs@N5#nGL>fbsPOD<2o zJ8I`R!9j8}Hbd4um(7ip(czyXNQi)-S&R+>5kx($5F49q;3c7?bLoChBI4qGE@q4k zR=`MlH_u*A;0UKH{w~APw90Ih14tk|Z&xgi7!Wv-$#SW~2<{qlZS+TsT&iMm1qAqm zMOrGALPrTjIvffwQvWfAjNb^2tAI^|jPdc6Sytwey5A@X!@0zc%x7R@V>t*U)}EGd z=fv);yj$FH75%d4Zt`G3G-v1JFhx;qRyek%@Rd!pA{SGAYm`mt_{|A0mbP?%Gzay8Hk} zcUCK|JSi0bv*t{oynYO&NF$?qO5pJJ>4oVg!xBDZWMip_#R8ISsx4G8-IumdYfDu9 zk4nrd^H0U7f2nd-*zSQi#?Z(HBq9A|)p9lKkPs?6a-PLa28b^im@^!H$RDD4ECsg^Ij0qa&xRxl9c96Av^daWo0GAOM6aGr< z5*?)ErRN@p#?Y?foq5g2G@|i@LXSlrc>eva zCp(e_IhmVx&14BQBTbih6uC^)gy8w3pUKzRY90hqaTNvwB&;MGq3-A;Q?wfkeT_q{ zD!3@m*mR9N;8@*n-w62%JndcCGNYW|gXXT9n~-e{JjbiM2GxS6S{QXvtWe{nq`3U@ zOHO+&2`;}8sHjoDE!w6NI2qY6$#;V9cSlsYkGvN&*vC?{BX++cmXx;&z2{Krdy31% zP7WLfpj(6Lg3y6sN|Cax7AWis#*ZumIW9JtA!!ScOO1oVS!D4irl4PiEM7FrxTx3V zN7ThQQmfKfB)$EZF;{R?U~g?*g;Xr|ffiGDn;Ceg9j-}LEM}0IE@i81nLlf>$gPA- z`Eq>HCDJPKQ8>a$Z3N>INjfddYwLm7A`W;KzBx<5W=75-XkI=E4CGm*k(a1Ae?v|q zS0102e>TBT$Y)Xd;)j(mdLbXlXRG_f@v^be7z>iJj=qkSUtA#~*fr)Ifl+c@eP5Fo z=mr9iyL8kk-?rvS>9vVN4>DKR-bb%Qs3?xmUgY2P39Sh^TPA9^`lTIE}%5H$eN z$h82~mqe9Xl0mdwUHB0wvZH*dp|r!*O5LV;VYHg?fs)2y{mWJaxJ$>=W zXaXNT&B+zZ-w(*rJapfHH=cjcbLzq(V z8@nd+B%=vS!r`pW0OYwekhfmEgElfxv!fo4hO;7nw^GP6%B}}S5}KKeZ)Di*BBNv|SxLaa-l zOkanv^*TA81fUMXkpac=f5I72i+E>W0;kEI)t?$oOy8#BOnRe$+$Z`M@ATZ@u$)bW zNg_|9_VY2TGwExZ`?%=nW}WB`TE{9WA;+rCSACx&-V@HfsQz{orUY#bo?lZdkI}=;+Ippq4R0Yz5hmGb)#p{i3Yac@QaJlIMGXLMK$tz@ z5Mcl$t!HupMUqD`EP&eNHDQB4sV`*9vaZVHb+O-Ivvz+~MB5(-H7RQCM(ESfw{#q< zNC8kxY=jn|g^hwJ&dBEUC7@6LJY1>m^K5y)!YF%oZ84V+X(HmAQy-TO@hq@$;E+j{ zTu|godGY04whq*w;C8r>ji(xE-_DH=Vd#(e|4itfmtWTZGBpT#EbW71E7^$g7)hS5fP-n9`4}_E; znv0Y`rLtOr1T(_C5)v{o-KvV`gIgCrjb#|BmZO{anwp!VMX*K5Ttx*5Qhy3@kk({8>KczLVd6u zr3UglFhf!XnAi!X&QwW%?rmoCyqEx$Ar8jlfFe+VW)r`Tsbh%Z9fD4fBZ-$}D7d?( ziwymMI_JR=U`8-tZb?n$S*m{m=CL||K=qAaBN#q&49vbnQUiC?FsS|WIsJlQ=`g5` zVNhjxkm5M}5JFOJ=w~@TRXv*`N(GP)0MMx3VrVsUU0_~?1_sI+$N0csP#T~)6YSLc zKsU3!;g?4h1<;&5@_m{$>r{u`9hgSDCLyDL)qAWEIpe1zrkflCbC(W*HB*zV&GuI# z)XRY>Uqh-eNY0*&p2yh8f0a+sGX0{+B&%28#>|3s`{9r|J5B^2;-F!rf!uiSkT zq8h=iY9eMzl9g5|(UApNY;reI26cVs71mH^yokpC-_#OdbX48U>J>~+XSP+Q|CO8Z zL@hkDY7x%~R2<&K427wGQr6j74Jb(0yeevnrX_vq($tci{cE{01Psg&b5e}Jd<_|H zzKzXnz--TKHCeee(VekawAr2UT-99kRO${gnqJW^eHSz(=G~#k2=2+DIdkwlA?0c0 zf%(SSy+WwcBSm&If%zm_sXc9%T;&EtJV$$ReuQ|Ba%*7))$)QSm zvnRG@{$CQ}6!2#3y}f+IEY@YHYsRV)jwVLv~Iw^6LkE5Iqa0Q4H>CJi_vy)s*odQq)*o8%;9L~^oLrF(*F!BEnW%*S>bq%TW?Nl2cCL?PhEfX=Kg zk+?V~2OBNA5|wFi_+fBH@3q3(AB)qsUQ1sRKCA(R0qp!3(4?6as1ZUf8#JmfZLt6^ zH?T@hLPHDBtxWKk%hoO-UGu4Ep73X&{#^!)rtjk?Enrg-2iou?z2-;6uauA*#N! zdmgV3&LW$3I=*2yh45EnH&j=I5$=(=G0oWy4bu@T_9*;D{3E)sp7@(ES!EV*#9vxLox|G{ z;d`@MUA>3`Gi8I|XZbCY#bTLGMu`p6%fOTjCB%}3twv=9g_Y#`;i|#B94R|GVxK3* z8sO&uMGanuV$Opj$&@VJDvg^m6@U4Z0t z^Fp<|eX-J;cC@Q~JJewQ*-6lc(Z2llQ2OmhsQt_LJKRoq`E{!GAmHubWW2Rqu~ky* zL2*W5{gyzyODCZe<|D`$O%<;5i6%dOQo*tzgH^ZG_*H)_%%_jQvLW98N7h?_Me%m; z?^!2WTbJ7-$~h|R_;j6_WDb7{{Aas zc{J^bM}e0ltcbPT+@_(cRBInj$6>lxHx8kZc~~deG(GWwcB{rrDW*xrNuhe^89hTQ z8PRMT4vu{FWV&Bj2w$p;nk$;{jR+Fc8%YFQ)7^eTgH%icu{N8=+(_mRn5Q~W%pW{W zbM1SeRiuNIhE%C?q=SIs(JMkWNy#t+9^%nI46q*!ynF}QeC=V+X@=;Mt{{_ToHq{b z6pf+o!4LB-ve!6fy`+J+MH3dP%iEbeoA%_bi_&Lh?Okb_Vmho@*<%K(E|%O}8!ktx zoF6b3q+kvL4@g8G-XFKhxq4F=A1AFtZH1s5hcfze$iP0au=XTF@WRnagP1|)h(+$+ zS%=xV^}9sEop3`9wFEAtINo^JNvK!A04%fyAwM-ztX@*b+1)SMp_0oeneFcMD$bK| zucuJh<3yNFgSS~DwOMss=~SCj@+@&y5opo8Jp?@A|8tOBsKT5%H>&GWUQz6EKk7^R zmA(4)rD?{?m2jOZlzxI&+P|&6AA0b&tW_C%9rfbYMwlDMbq(haq}Wy@SFo;beE~^sFiHDPp;;Y{bZSMN5_jrjeEO9yU8nxzfm1$=)-RJez%V+2SE6KcZ z9EPm;Lv!?>+PG80;lEOLiOI`^W}zq~U~6YIMbxjnOSR=2k$b0~r{c{-7;_otc|m97 zhq@&9AiQs$X$=~hpAk2oN zy$NhT%+v)=cLa~c%yKcT)fL!TGY4M>3^cQ_XjFdZ?&7}K*m{@Ck3CK^Zd@7C18%rC zXcR^?qXs*+Y9uFJfE9Awwrw(mb9EDqQIEEx{eZ5&!OYRf<45RtR7MGvUy4`^lkc z-;>qv<0=xFDpI`r`!&y%k8lK2_~P~PZwuQ(|4)5}zoW*%an*3Ja<^s80*ie6%Fm6IU87p`q z@Uq||V6!dje~GBBJPM=3H%nVSes^mX0nvMW0m%Imuu>!Z+4-QS6w#o$R~Csi58Rd= z*1WmPzyV5V_A`Gp^c*!2sCahK#U7#S%|2`V1V4P;3nAA`TP{9oR2;7*7c#5mbhCO4~6y zg@SjJ#t>9i>a!|2L8v3f_2JnG&J`xv3MuU=&J}>Gs-&o&0eJ=nwY&jax#ppQrfrL5XU#b)D z<|j{-vYICb%_bN|%(Vt+E+X8Cm|LhJFsyGh7i{laU0(Ej>PgkTT<%xEN{M0Nm=n?z z;=&mjjmQ4xZ8cgpggwc*J@PUx>lXRyJpkGE^$<&uo*=Ki-_zf-IG3}w4xA0)>ha@Bq3-MHgOu0;p4&pY+ zr=(%0q8woyVN}qZAxed;d`|BxEKt4iBzn%q25t_JPEkzF=Y)2%f+-R_AHwA?5*~S_ z0S!-{CL551+1on-Pke-vefUwFo@_n~)vkI^BA?ax=#q+@B_HcJn}jG%Qu#BLJP9o% zfvaBeS=-u{GreLwms>UXc=qJE<>f_*Rklqlcm=#!OaFP&da?9UJeS2YC|$1Y^Db$c zuCG0uB-9*U!h>j+qL2&hW7;>PX{ttaMdxDl~l+kgtH|M93kD;DVl*2!TmiT`P)f38ql1T2%-dqkd zd^E#M9`FiteVvNOLr$l-eUvtI+54zUdGPHI|Nck*=GZnD=no})&CyA8pKCF2(p|0~ zLUBlf%q6&NGMnwx*pQLJMkm#HdW86c(m;|>*>uO-Vlr={TUh?K-4rOyu_ zmVW$r58jQhCPQeZgSPkJt(xW67u&M$C7*yEWZ&xZ;>EYTa3>gB;GhP*COuBVZuJw} z1X1(H#Y(X;PPpmu7KUGG*J#j-^_$TO3k$;t|8_0lMjY z(5|iaI%fIjksdcT|0^Q?_`$%Fy}QzDg;`<~vrNNHS|%`@<&!AfonGxOggwW-yB%Kh z>^uErHN5T#7uek6?a`mJtNvdw8~qLA?Q}5at02=X`NxiC(0h&2Y zrP$mn#uol2_>XSri%Q+j&)T7pu?8!v8LvN2Goh5#6ywtTc!hp{Ml@VrF_z!C?P2y6 zyZ&;Bu8s8TaY~WKG6-I&`vZ_ z%(R_L84UF#rVfZ1`l4T5NnSu5Cz)+_n}erX62_yhK{ z!EMEoUI?Bpo-YFvbm->i+rXx3gWDd#Xc?GKCKgT#LrYm0yl(D`mr-dK&e)Sd|A7_gcEl3iYHRkh^1cBglt_q#L zcdcA_elaQL$J%?dzmKmS;je^V9x|m?!mnK%3@wGkWq%(Y%1@z1$N@Q`;?(JHWbL8m zU>iw->;5wM4@l69k@49P&?UMpTW&FrJl3g>H(B#T`6}Lll~9u<${w~6YsVpJ zUY0|era5ARk;MD~5&wWI*@l1mffjxb&jV(1)e>NsbhgHJLEhP}#&(+EFBAa*5Zuz( z@N(+7Dmw=7#~Iw$EO_+e56qdIx%aJ%)Ucl&=5PjC+>yOSk7yqS{ibmJb5i{xh4})j zlo|`>rSnE6W4WA`%({D;an*MidzQE(mcre9mwr-I&PR?B!;8tu-s@*I%ogbuHwH#C zvk6jsPPp$ zXsuLs-xwi?2%x36C$yaN5=X{Lm?BTmaFp`{A zi6j^By&}Ryi#!A4od?kKHnvZb#VOx1H3?y7Bo`w`8%tQNeY<_w^V!pF-&y@vnea49 zOmZl(F>a+|N!9U*-4Avj3*2-I%Z6Vl|HkCZR>|Cvw<2`!R~{bR z=T=F1R4OifDbTYxEr;`<;IeRR(9R2W@IgYD;e);+peqmMBcjW1^eF<0fL6>DS=od} zcE{zht{Nd;L1Se3h)0-z^2VQca9dZP50ap1E|sn87sYh`qpnw^w}Z}rx4GjS*<*cm z*t%}Ll=#S;e|k~aJXIUD!53?CJC~r>vCW>t)u*4QxvO%o)Sk{d61`r|)=f#s;t`j7 zPU+4R(D2_}Lb&=~jXv$(9ghW(?m_zL`-Pk)&XHkx#zzLPdB=@sx8l?=K@h&PNMdRj z2i0}J&LCUY_H3^*q?|%ZG{Jp*DVLZ9;_@~*Oim>8fcViuY0N>8Us01IRT`_-y(xMq zy~?+gK$Es%34fY)@gi?V0~hGxw$Rts!b&LNDS;xBSV54ORfS1o0cB5}Eq|LBNBUy} zdwH#4a@Ot-@(%L9a)Qw>Mdyd9SwM2|kf)30pCfj8+?9P0e}f3zD4{66=h6KymyBvN z`(o)J7%3RJ3@21yx;^^~#m)Y~DJ~_NSrhX$gT5<;f;$1f5T0eYBj_?94i7yFH5opw zp$VI0ie!qU;hUZ(=yngEEK;9F+G#nNd-`@jfj49XPBm}{73c}4r&nN4VP5v~T{A?L zM;%+fKLirV0L=i6Xio`8K%upb0s2G5uVxkE#4I4kMAz3(e1MEZGLj`0`RKoq8~D-P zR+HHh5Pm`1TEYOuQnIdFeW z^9DdvGnI_u@gpsKDc0gXoZZN)Cqn7y;^T~4xxNfE=dkCM*oetRo--|Mg$yVSEn_D5 znFV|$;_Bkm41FtWQ{8#bak|X(d25hTi222Zea%o;%jBl|cH%1&r)_t=R-Aq5`q&NP zxy)fS>e*tE?jDFZiQ0x$xeB=e>5l+2a@k`_=;vqmB<(&jO2;D$hit}G8iM^-(s*zP zb-=N5!+c~YCsSUEv?uE;kBeFpyTm?Il)EYK**w{P?#PXh$j(aB()Ru$m)%pc?YX!p zPfcI_x&wN(DFM6s$RThZ*D7_FMdS!wu6+MyO+mJEj$DEvY%19#KC}aH@698NWT$!v z{YoPRqwe~)EbXu#3a71#=uF(5vt>r!OKNx`3~0@Qll4z+3;CNO6c(i0XtyuFIs)>N=zg%` zYz&Vs2|Z!CiJyV!SLbX7`rURU+p^2PJ|5*j;+_}xHUE~Ud_SoPme)F+$I?>$!w+|0^Vd&+*F}_sVHLnjc-ot7K)GHW$U?cj6ZVyzCt_a2vt3IZJ+Uy3Kq4;=6deWe- z!AS3LbA6WV1LV|lgdu8c`BB7D--`W3;yK&pgD>Jb(NHc86D6S@X{_L(EV!z84_E0; z?^rHAtaNPto4%A?d#dN9kWeO&Hjp%geMWGPyaO-T?qRroW!tqPrmXVQmzb-v zU-C31+4T>(Y?|w;4C_n8D}PMBu1G;xZrK;vW4X<533FXm zS!kOz4Nzo@_7?ujJiznU@2(?S1wFIXJ&twZmG8x{vG7;LuS1oKm_HeQnpdL1jH3P+ z7XqV;on(T&`&ZrxoA`S+lPEVLDrZy=b*XC2WxF2rEWy#$@U4~Dn*Z?zG>^1BZ9&pR zjD%hHl{F0wYjck`^@RYJj8M{CU@>psBkxZ zF#zmNgnvCGG|_;FmcmeY(Lfay9T$sTzd}7$|Jfn!QUE&<;(eUCr+}})@nf~dlh9u9 za&@pixhQBIHEvdk81Pd3G!!*VOlI**u2E3%k(4K26l*sdP=CHZsKv13zV#sS*YFu% z_EOmbVHgsuSjxqITENL^NjT?d5Zy`$)84g@C>xT4_h}>WxXt_mdAH4@7V8YfmC7En zTlhp1i1d4$KPhRXqm%3-KVilny1}+A>;S0?pFz9o^mwE?QDenn=9EP)`>ICGPp-cg^Z3dQ^STh zL3x3J*!385j@^|`-1s*sw;P?rDdyFmr~%B!{4Z>@fWX_=_s56#BNE^FEbk92JONU6 zKaaA~uL2lPLCFTB>`%Xlc?7ht6O1zFfeK2Rt=OpgnXQ;1WD|tL#RY4mO${%r-zFMf zNM1;0>gs@E#5XT#QOrXLT%Q4BN#!eQAN{?yVkyA?QGN>4*~Gzk4rUr7QWMf*|DFIaiDcU}z4l0_Yky$b ztk|r$ga7W3%6&>L?){vc=zZg*8;edYkov>yDP-CtAEp!qxP3Is`1$CgnIlGq@JF-W zWOUuf&nYEesf|jB%DnDf~cWaMkw!^g**Wzo&QsVI(}3ZI8wo z)(hnIO|l7`&b^tcQ_V79~?y)Q?be6fX^eK*`Di zU#>#O`)`Q?^g1xl6g(d!;l~TQi~}>8*!;bSs{bDmRoCpMs18s)?%5mN+_d~JCBhpq zNBlX;{gIwrTH2D(f|A=~=U6bWL|HgSfu$!;9tuJb{$c*Q=ZDB6xutVIe{LcOw?=9< z6V5qz3WS73m?8cfd*-{m4Vj)@K?B`@CDvil!3|ciSyCb6h<#UdrWGcWHZR_Xm~W-|#gltyOs1y(1LE7st*I zA0;gIfo_tr(hCydD2FNDNP>!D3P`sGkNPepJ_B62%gL3wd_8)B)_1C%( zy~Km+*%_Rm#;E!vS5xu?9W}hpPgq>P(%5@YYMuHR=hCn-!tY*OY}gqTVQq0ct1=lF zrBT-hRyj>ad zn*{+bZDO((s3GAYIysA#sT3|Lb)q${=gl5Aw&C9&QcZ z(vJ(vAQIMZ*$SMz$KZ(uAmsVeQ+^frhPV^S2phYs5{KcC941bIq4Ig+%~)~dwg)o9`CfTpq2aG>n%;AkNiMAvmMbZ zqu-bjI<_RkT6tG@jI877B1aBeYrZC>NHF|Qp%vT-93%_72^=y)a=Eqb?BHR9u5-A> z{-z7ADBotwN*!q`Mp3Ra~e^3CM;+Hx(n2)Yd*SFzY<)JPp{>=%@Iy73qvisLV@-P^P+L{w49= zVsmm?HKnc5LIW~J&BOopKl?mHI!T}<3aS)#l-#eU5;1^QckHqF~YZXtOp6U0>&V z5kK-wpVJfsVF8-_X8Z~yU~C?8Uz@ru5uat@|!&N zh@ZfrAu^rz4r%!GldvZ)C>n^@H-4BS7I^@avTu!1Qy3Ss3J( zr^~O2Bv08x$p@uxFR)U|<9v4njVuI>M#W1tX5WLi6-PxN5BjJxnGlUkwv1}gem?>S zrtbZs<>62Mbm?DtArfYlz7?fTr4M7xtQPk|+kZe&RlJ5Tdy21|t@6i=i4THQk8wCX zRladZ)CGDq2^;mHooRFU0lGgGhEol_()$!~0hFOzfGr$+LUHccLdb?0~I z_b}(W5s$bLkC~5|XA&44YxFk#%+S3ZXtS7^f0@~)XMdtlKL^>NyE**gxv|i6K%Zjh zk#rl{wK7nvTCo$`@^Se5LiO|Ky)nD#ushX|shwF1_9KDcr~Sa#g4&^Z=9|TnlkOAi zkaqa#Nl5z(sl_U`Z?8@zxV$xFbk;;0W8TV;6>Z5#GGR-l+)+{!1fdwBm;1SF*q@hL zl%z3SM`50CKHgJsRS>={4QG*WW=0Kkj-1igZ=SOp&!)M!Kv3M8xg{lMX4>;u#I{U2 z_QylEN_~x#70duf-J|ifT(rr&kCg|_*O0Sdi^>l+Yi^Atc2iD2*Q`{Zd1Yz#D8MO7 z=y!|z1iG|pr`T>VvNe!6)$K;zKR$R7^Q=my&J~^?LWuzTsV?7ttN(9Et^6 zEIcEy@l$~}rSxV-gn@b6RT0Yu69N=3o%=RlIm7LF+_WVD859XkjZr4CbSwLpQUZ4H zp)%)Br_Rq842o9~3Ux;M+t=ky)1Gy3xJ}3k72}urDn@N+R8xOi48vz#oekMj{+=c9 zrAU*~>!>C*me0Bv(M^^uP+C`2w_>$JnJ2NeEU%GcYh`rs97vA{C80Xex`k^j5sSjo zM!dP5HqU^LeOIBJTN!)8ty7i6=*669-~2uqdpxnnRg)xFW-sFwZugF?k39>C>`d&? zZbI@$z|J7l4bin0WL3Dc)oS=NsG+>^ba%+ZLV9>*FK)c~_;TB&o;c{tEpy45gS^-V z<0e$E=E(DIxn@o!c>hMBa{d$|qS8;h7Ir8Js9uL@eID%*=?N66c5TDM_pM<(m-xXz zgp!$ZDKYt$Yi&nju(x4tR<@y?d+l&RYyHrmEPk^faFB^=L!8rm^~<5e3kpUGL{W!Z zdgD7i2G-GDJ%*~+Rc+=KC1&BKIiJqYaO#Cu+b+5Vp1?k^wici5x}J%@S}WOe*F=KXd){*kL9yU%K|Cy0gHo1tn7cHGP+`f!)Vv&;$gF;RQ~gT&Q-s{p@evX&{irkY1UF=dZDJOTvW9Z zTdqX>+H~v-quLYSE(U+4qS0d{(A!?d_b_&7c?M?(y`hgXpfw?R*B+c=AVj9Zdb-m) z_9eQrRYIb8NHaS}zCB;ZnG(AZm1 zpNinM;X7=M56zCydgEdzC<;4(!tScEZzlw3q`_6OA_F&K8>NIA>QHPl83Nod57}Cc z*LB2%fo z1I2pw|ZbOw5I(c-H zR?7ccSS&To&I_Oz4CgvHXCHZNwl%GQD#>?7?bVF<>?7PC{!Ehi%-%B(qpLRji1>{7 z?CGTJRIS2b&7`!mr_&~VySt%hW$<%$$a3J*xOVpl$gwK@YA)p}@DJ_h5qZ+f^S&AN zfAY@V`9i)v-73`J^IBFoRDT+zazTAji0W4#K?96EfVBXY-wksvoqFa~5$UUu>YJa? z+Ww=+WLlemPB<{WcUjB}X4yC7$f*j4Lpo*iAVYD4m)HKGgshHdiNesna_<8+SJ%cO|p&TO@I2=mxx`W|=h#iKhT? z_jdR6tx%1_M~ilXUJ6bF@WJAzjTKuFv_`PB}skLEhEQA>4yW%W# zgt7-au#m2f&A5$E^JlNVhIvCo)m=au!au$-U zWcr>^+fy}ES57ljg7_y3Ku4(kY3_SN%W=CX_~EN^&nMYBy%H$4?D=s#GWi-&HL{F! z_=N_H2qvDuNj0ps8eY$Ca){nq_|EKUPjd23y<@&*h6+B0qnT<)%15i7tMx&UVI$BG1HZpGKysRO0GdWl(t+&)=m{fvLe??XTaI4|3$vl)Dd83W*V5IQXOYMk~5==%Kl)cI-xS5gxSfZh+myR zi_fKqt}PDNdp5Cb^-S@KeZ|V+MTTiIbbN7*fXVuaHFQ4_IT2YqxC0%92VFZON9?5P zgV{?1<@d7G6rJP1vehBCe8v-N_9adsE~REu%Y=N3LvH2_h?L^CsmX_K2svxL?|&=8 ziq#c=i4Swf{b)B2sq)K&dkc7Yq4loux4yDoVH~hi>5^!pn`PXwej|G^g?CsbAmw^@ z9=|a8*3RM3KDam2jG4SK)%Yx|b8Z{h-N{KspT~>U9ttq3X%6A~oqLV8kk-BMp4s75 z?eLz2FVT>w!@DhWHWoAGvrpHH3l8t0Z)lI~iB2s&TmWn- zgnyc}5>Gl?srGjIO?^*~!GDtl6hFU01XseQ)SbdBt%Z-uE;=LM>`7$uwzXqso+a|d z(!|)rYcz{9{!-&szHPqbMla`4DKb&Ov$WETdW>(GT~)eCVX1kyYILITb<%yOy&d!rC+)!OX;dN{8eig;K8EwCg zA8C{IU_ypahH$7yj05rF`k}Kl>ZWGwRIyf$6zSz*Om2d4y zEwEJVhy`L!(OB$ z)~jB2%+Y3DfCkK~&#F@j#cA@1xs~Ou$+}@P2x(wMQtVS;KetRGXP{8w6`!(~IUTIu!?U%R^C2i~At{Hi9lE{@%1@#CPD(h7gF9dc^kr-pb^LRUn2sD&p**l3W__FZN%VBnVB(^pw>@>Jotf3?a;Wor{^(MM z=o!&7fM{5q#syqk#?W6d5N&3{To{b?7xNZteRmXtP7n}*f{O0zm(Gap+aMS5?tKKS zyMN-H4g0IcL=POAb`3WP2R*?Pl)ok)y@_Gb(0xIOyoS;Juc3+_@}n}r5?ioeXtK!} zvro4Ac93jn@US4==O)o4;A2tir8I*%IJHK zEOGy&3{?4S;5fjyt#~d={g!vfbY=Vnz!fv9i(Ka!6>iJQ{p_faoFKKoA$jFzWMnS( zNm*z3p5EA}wG-BnyVzT&8^*nEhcig^uUq^Vh?qM{gc=vZa)D4^Ik+^08ygLyofG;A z7zliGR~r6JEa9pa+Z|ZKrma1i$NhMox?$k_^($gBOZRq_UeI#Qq_#Hkw{6qLw(Z!Z z2H2rQ(8-dv);{*>r>0UEXZ8;vt_}y!f_q#R7W*%}bQjux)Tj#WN89;#)qF3}ku6cJ zB2z1=ih3AhHJ1JOSAheL^;I&*1mh>^-;ZHW%kKM-IAIMXhcyp6E+p#$Pp{yFKN zw&vPSPQKCAaG6m4xRg8d$!pv3c4E$^WoB}+L^j#ItE22>@1+iAq;p>u8Qq>%oD$uh zQVsO?5X|{aZ^JL~6gOokZ2L( z(>7JGNC`OVsgB$XT?SN4c7&O>B#t>X+1HQ2nSF1SS@v$i@^+Hls?QnYI%K*{mC-)m zzFuiGa461w8Rby?22H&#M(1U^j%W!!_4p!Mq~!}MfL2mZsW`h?SBW`aEnB%5hW9hU=L)1*fam&1wmBF?>cQ3|C( zf`ShK*O|T*$^>9Of1O}oDvThh_Eg88`cr6#e;jkj?vqVEb674xc5ZF3Ec4c5Bktgw zGx>XWwq3uvl05BlH_=7hWt^X!INkHe2xw=$uEhG+fQ>;D7*|Cy>HIoU0#h&lFi*=W-UNeLBvk46)H?P2(f z@B`3ZgfssTIpwWF#7r7}k_cc5BX&yXQFARmJW^k#!c9~%-JwzCj2@#O=Akwkso;>F z_DL?qO(^QKo-6|ITp3$h@`J%)>W^313Gw~nfDxR%)(-ig2DPtQM8)z*Ode)1Jsp@&?bjsYht9@{|?T!1y z*gXfD^S}nGI^3(#>T7orrk*l7)n4Mox_wXV*qCHXyq#_6xG;_o$?x-AW3WrbPt_vY zy_y8aW&R5wf#jWH5nh3ooywXsJtw`py6Fp#y|JwwuZ88!ZI-)!dNu3a@a!7TDr8Oy zmb>*ER(Cr`L8s&AbHwhcJ@6zqia(5K>b;@)GOX_Olx5*?{(dSUQgKNMk6tf?XguXX zsG{XV_~g&)@G7wQO4Z%ymFvzT>M4wud9PRn+q82~7RB5r%u%k5yQu?6qlmgX4#>B@tv_k8TbG|oa2QWjdQ(xiD_ago! z?m*c<1_W|itZ6z>^NY2yFt8G`<8?Bb=`rl7icB{pbtT670{oxlVZ}7)S$1NSa6o+V znx-_%qfB86%h2-o5>~h3`_ym|_c!;$@b8CAc(P60k*2mgN|%1UIixux{fvJWjFA|O zjxfIY4kgq~{Q}vbS7Z^pfoT0-FWZ0hQSiE7q!w?M$i;+pA#gD( zE7&JBIylfKiQ=~phxKfXLR`&gjbx0x7q_jl%S~EzVeDNR%#r0_gh3dtJz)g-mC85_ z$Pa}gaNQedjKJM-#-V_YK@rDG!xck^a?3SCs~Zk^GHJSKN;$WJV6`eNhhO40f?Pax7{;bwUk74ese!B*@b;8g(7m>*91m zUFRDW!=h+pI1#2oM!o0u%{M@r38`uM18(-qtPG8UH|3=il-eC)#yTddPSMcGENi7| z{;#aj6~y8(;%(uf@`xBi(U|hSb+|aDr!?Rqz;~n&To&gY&BhtcW3rq_Mx*R{$AlkoxwnwxC5+OTXXOzTef(P zztfHV&@&M=Q9E%=uEG4hgTSq`30Ip67Z1uM+KOmLwCDW!k7%befTLN;w-Pk8^4t)g zW*(I(N^J2?EX7(^#3rZgL`_a59=4eAzI>=GyriLsEyk7jV0SJ(4w)a%Ijr$Y> zQFv<#@!h&C&`kk0l@Y2Z3T~MVYm;-XBeT=RUEad=+yD1+oUZ~_ z47%EG3}MV7L0K>*Xnxjl{x?S*$!L%hS#0FSZk!dSClThlzD(W*qw2r&|G=PXGF9iW zq);R`V9k+W3Tr(QY(0XEjNVX<-_;T6-uBo5BjIO@u->$Y4@cB<48aES?qm8NtIr5Y z1I(7NYJf9AB3F3DP~OS=0(Yl+2$K4a0l}l;z0|yKs*fZ*H3|)(KV{dlkA`17bzRR8 z%?SKw7$p!xTAe*hxlUVr@Z4GSnGe9Kz{YW84_zih{H!UazGe z0fYA4LpM>csW(06_*UMD=8|afK{74#Ec1Rw3UNtuANSavToOsFk*-E-tPLL{9J;?e z6yjEQ5o$`|PZCP8F50Z-$5ZB56djOW?;GU`H(9^J@l+$aqb5h5P}I2qrg z_D`@vcIKOY9v#~L%6;U1S9r037azj@2{;;;p(xJS!A1QZJ+|MY$gIzqRe2KhJX^pi zL8*QQ9doN#&553^6SDeClNyK+QQ;uN^DtV$vXUKu$id|4Jl=UeCUnfkie?lkVs5y` z79i=NFf_p`0BtzXPu6@m&_u*x7;WSA%z4_mXu~`A_mWXUjRl`i_rJ3wCDcLyQ}g|6 zkG-`$r*A)dWu9^08|p@Y!<#UZmZV`^i!a3+NhF~uNhF_SSYEzl7tl@ZJmf}d^LWPH z8hd*Dh0Tr8QW{bjj|f5x2Wlh)@!(AQ^5DRN7GJx+k%$eNdY!lIoi2V#`8h(UlfoFw zO)l5|_mY5CE}xtXmLCQlBNHII_&KPKQ!hM-0tfm9hAQA+r%9M>^>>PU&Ai?HwBrG$ znK<5XZ8g}o>aRMj`~jJKzn>#)0}7U>eV^Q*T~yi<)+bssYOGgKBB_^guzk;aV~Fa6 zn&$oPgyOEaHkIKx;Px>kXmY``wD-T}%rZp!$wD1FJEc_sC@g3-=c7g&;w=?zeBFSm zjA7Mu)0J%1ECZ}lnkm5KgDQ=t`I@{E@fQ!))21vHs`rYD?n4H>JhE89We0BxB31l# z3nKf?IxeV2pmZaXWF}3})1&us^4ecmg|xz}Lt5^OAwA#&tlXQ%=1SrM9FJz2m*2dAhWwy5@GqweIS$W~XTfn6;HRl)6aO%6SG(>LLjUQH+O^>CNn4 z-L`yMa=ku_9bBEdaw}YH{=YMAw6^9w&cLZQ%sFdeYDN*fIjQ=4)|y+_-9Q8=b`_j8 z#ojL>W@S1Ivka}EIfm+OHHLFXKu`O#4o3B7a57D*>g^&ic{zY8=50(NUG?^WI2|2c z^dd7^wfau4TWQu!2zTC_d-$=SBq3y-7m*oG>B8P~qF z>!w-P8(I0cAG@4_f!j<6AqPDUR!x)EHjtH8Ww#iYCmISGQ*cP5c2Q~$V@<}Ygp-I( z&Pd%o7s|>t%{RR`PgrSVcek^d!|(CW>^x>wDb=|gSqJbjluEBtN#{=v2cliI?e^KZ z`C7WgSwg->zqE#}Tha}=?mpvg`t-%9YP{bn*5#nnDwb;|-@U*+;47=%&_wUKEYBp< z+X2ay`3Um23)uqa5l!y(`S4-oYdgUNeZe2DEXTF;Nkem!MN7irJ=Dn*SEas7k-21B zH#OB@nFRQp=(Dh|Kd;{ZfdLU*?i5^Z)e~M`9_BAz#8pjav8}bt#WOl1rCEessFbEe z*>?9Hs#+(z3oz_;naLftJHKmQ5nicI(s7go11IrMz9kkjYw|$6B_Ub{Yq^!yAgF zAXh!#J9$0`N?|c|jOG`0)uXi;6*FgdMS(|R5dgk%A&D_pSy8%m>z2 z3%7OGiXvE&OHkL3@VO23dzx7hQegLba_-isVOIVQ7g!Q4*uaZ{=uwQR*$pS&Ox69VHaY2-UmcY>3pP2@ zZPOHd6tuf3bnqnS^G>3)6^+Krip6ukO4^zPWP`+UEzy;H%<&~&cq@tb75tU~&}Gos_wtl{l*Fmno#R~};!QTn8#n&L9*Lue zHYJIRj^5=nE|!8L^hMh(_M0HJY03|gA0jxyKYypj`5zoQo$hM8vEL%*JeSBP{@$uV zuMiv(ulwUkXJ2IFT|tWb*H$=vQ^9eg=sF4Kyc_q;PHPdHb}m~8C1b>4i8?UC!9)-k z+A&YTVVby4H(V*k9{g=LxWmxiqzB9JVDaOkT5$vJ8YEBzuqKpZ{(O77eX+ujNK&hp z@)W_U@2vlVNQB>TUZ`ujs?vmDq4~33M>gB%$&Ei+>*0p@PgmmimYj6^mvyrcx1+G5 z%)_7elMp!q<3Hl_joYCDO+CsU!S5XRJz=x4YAQ}Pny>hlAnCtwgR-ddr7!bhEs(xB zF1XW0uzYR_iBgf#s*5@20a7JN! z&R<AFWmg$nuV0nU#$ z5kd^b&t~w7F^SGSU_n7)H|O~vw)tZ%9Ap*TqWTyG309hQiL^i4xE`^#$cU5p6SD%r z*^j~=Tld0(aVa_RN{ z@5w$gz(Ja)zn_jFk08Oh#mGtGa6|CH$+ko0N@A_BKEouoyx}WXX&WR1X`8@N)HgVj z7~4TV<|Z+o$twvm{ve!ZN>&|LEB+_5%L|5n|XtLekgf z#sjeUYI*U<$-CkBTQSD0qFKy|W71cNG17$qqlGU+y_|bL9)4&L4=sr;i5<|VwF4t@ zR@@$fkudAGoZ2cEnxAMs(X4$Tcp~1BJoiN@Rw*`7q_@wzJp`{Wt+md3#|10PL--mi zjmCobMH)@YcYx+1i^}xp(O5J~-qLa&kB2YQxQU_UH~R(nK+fB~5x2W@d{L)>MUltsz=BvzeF@8@hEqHs@p*6g zV}cm3Uh`6G)#4Gu1Lx160?|~(?zPRArQ)sCg_SwyR?onxpHm~N$7TIP0vitT4lGxk zEMkD}*@ykUgx%vU^L?*f+b!4HrJ6J_dcm8`NIpd$-k*7^@8rfWol$NbI*xA`oL~|p z#1aCs+Bp}i{KlmT=I5&)#9-~uqS^AskYtb(UYa9-Jm!*@RDQ|$ z+0on_=`V$XhsQCzHW2d%{o5=_r~DUhFf8$#q*d0nv}lc5X=krO?3KJ58>x zML~ynJ3i@jta10cg6&6lnmh;sex&UB_iQxwx!Fv!?v$rp|YGDBCij6sQ@gR~f-`_I9P zfRXCLYs~yD_+-t-$5F=wYVB;N#tUy%<%qzV#isW9;IJ9FSSN@CH- zrYV6pn(M4?#G(<@P%fM1tbJ{rjQu_oj*e42l(G4S{U(RsSJ7QgY%N9BW;b5B>_L@sp$@rFNB6x1mw41> z%kLhF%5K9cD#|hZ$X!Z%RxB2V>nf>H$&v8&d-KO^BUI&gdO8yROTe9=&Rk1&UwN)+ zTLY*}k=$nR%X*tivh;HmBG$cohHeI**M#m#f_(hdBg4VyF)fS_$O4Fljk!1o(SE1h z-VEov77w*%3wl9Dck*D;U`6%8_o8DA%i)T^cg+g~ea;T!mJ0@twN0? z&-omW*zUt0r?5z4%zCfFb)TlTwzEb+{5y3*ugc69%dWc)-E>p=W8dQ=6WKox-q(%e zrwy?H8NJJ?-8Q#AGh#EMuDQ_*?7>&&oHSKDUL_<%nx+P7zOE@zd+BgbB~4|!E&W-* z82iI7=vhpR1Dx4;oJl@dW6Km`fi?%&Z*|wCE?cfE9-SWupCBX2FB^P_QT&p(VgQbt z-u#{g>V*I5D9D@~XLy;uSq?!x+UNdZ(QfUTLCP016vUjR0s!(a{-07$2Wer{ocv+M@13ZfG42|_= z0}>P~ujB~2KJM_*Fq^CRtN5O8wZhREcOC)WW|+;V+RNM;oo`Vl@g}$K%{9OUdbefD zKf_LBd(wBGnD7%Awg3BJZ>No>{f%ujDMZWp;34bd_(*&%0!Ew>LC@V)^}7o zb*t95E1W_0t?@5qioKZ;v~@Asx*2@|H1Bbh8+8VZnm0Ia3O*19c_rh&d9Pdzx@B>8 z-^5zir_bM9k40Wli{l=m3=)5H)eIkVQFI!>2mCu-!2W8?Ux^P`Yw<-q7O=jXPz9nyL@D#AeBiZwe@hJ18nGAG)UK^Sv31 z(0A*4K*8O-mQ+@+uO-t7qgBMGK!S{1)hzkUVZ43YoK2)@IP{c`EK{WjmOZ9G%m8Rc z$s)Y|Vr}4|v1F_nJ3~Aj?Rp?A?v^5vsLk7-(z}HW&c%bSs7D3i zu!Y=(TsA0$lcv*z%RWN`>z&yKp~V{sR2wB0Xik|2^_zWQ-R6M z>D&r#m@fG~riw*F3(QF(Byh<6!}KLv@$ZJERuWb;1I~{40u4z<0^O|}q``OJboXt| zjg8Q$^GrHZu(}^4Za~AZ7jo@dRKcczl`I>QmcMJ<|~7hN41L;~`4wrOqt z5&ucwr<8MSQY#Xi_{cm38SBa8`5Xn}aEPYmcj97Nr_t&hMb?M7GP0;oHMOlF;2sL# zjNB$~gKavG+zg0*)UCSH;yW@4*8Jgr@;$2$=3jo>PQhW=!?~!Dg-5x(k$jOMLp}Yl zxXO7}bBGE!Qr5A4kOafxxMeMuNmX}(1)dPgk^WUcbkg={JbLyL=KE@%s`aM0#p=sG za|+-1M)do5o=!1pxh@6r0ZvQ?hv^0s22~(U@nnxLQVW-XaTIK-l)_`gi@Tu!jw5T$ zezKoQwaO5XT*P5tWxE^J@nG-)kJUc3^I#eYOE)x4~Ji74QQI^I^|JW!?PNBS`k!ymzr=d^CljDkP;)2| zJ-RIj4dxvSX_s#$6_bDG6O2P>I6)N=%j>s_AcX5$GzNdN-+%c-#U@?ld~$Lf2;j}q zOchI@hXiV-o)5FC^wFt^52Cm2YKyiEt)-&^}Hsd_whAk2>ccCqPW zT<5puvwqXX-1H;>$h_eBfAu#QMdPXa7$r)xe`063suX%Tul!x}JO6%vAP7bHnK?IS z^v!zLYZY7!ls|L0#SFM_9=ra99d0VU94#+YdbQT0QU#uYI5E5bzu?c>t`j=}z3-t| zb0!Wj#R=5cIUjKFu2G2bo5!0@YH(rAbJ${~tPtKV*!-&$4o*M=t{l_m}zN|ZZ_Q#Rmfvecv5|)YEMDg8~!$!z0 zbe#~1IVA>GZdD0W?tAL?)1`dC`}>3zh;ml~5TP*;{S>s3(FSr~MQ|{5$)doL;}~t2 zgvB!S75r=tIE*8}1s9+YvjDNn$oF$5RjD8wdM@t1^|GXVSds*2PEA|?EkS&T zS~W!NywRKWgiWw-!1jAaUjN8`^SxU)zD$<>viU3%Uw`BjOZf;?q;siC)mV?mf5_$* z$E`&$g`D8WvLk4bicLfK55@5UDti5)nBZzZIXioGBjVM|T@0?^6v9V-cE1YeTmEV$ zya7{sZ+v4Pv@;%Zd}=Oz!`bydm)||vMMu(Rdwj0(D&uJF;TV;9ipo|^ZlCHm*TY2Y|ZV0M)ZHJWsU2ixM7DNzIz!zn>Fr>;cnyK6HesAC}iFQlBCslT(v{(xId zSuT$MDd8J}F-IGV6i_>})owxd58U@qT%8kE`2KA-JM^O&O9Y5zt2F|w$U=Iql0tcKNddP$P~>jWm9(xF@PFI zky0~)*>xb{=HsIAB*k`=yER$ET)aOY%A~=xo{&rLgNs4ifj)rZ`#KdW%#V9v1O*n3 zl;z~C2X4)bK|Utzy!@goBqgXw?@7-HCk6dbk4@I-o#xe;f_KRuJ(TvWZL3HlgAPy! zmFBsW;oQO8(b^AbWKmcMFeYvM^dpmCO#z|%0O(d;r<@G0g~@83CBRU}td}E85=er; zS0!%1$ZvJjF^;wRs7D1nNFX+7M2m-@U9h_G+XefBaWHXHLA&j%bwcL0nd*jCrWel9 zU_19JQ*zt28>%S!00j%RjU+>z~qdw@SC3prq(0 zKBu8Z&NU$?*+*1|QKnjtj0&LW?#Z}+5FN4AXRw_=w#M$p|FMVbh*p?Fn6fAmdFG#) zz-7fl(W@6kp8qwBu@d2zq;HuR`#G~Sz%b&!fgGT_Dt_5=0>%+>BfdW>3>d7V@y7@w zF~4!pKePa0EA}(+SM5IMNSa)wPeSLHT?^T3rVQi4o=Sm!ySP$A6e2M1P<8Az#FbWS za>SdIeLAY*AXVIL^pR=XmDkM}1jXZX!zTDMt%oVuHDS(aFP*=YxncW{Cac;E#}CH? z%fpTXXist+>KVbF*L$zUwT+$0q}3~Ehn&eo>+H>B1GKfoPdCQOH5AXg8h=o#wi&G0F^W7ULyb1c{Em2i_+dPsMYvd{~T3bDUVs5ZeTfJ`7#XUw_{d z@vRa4`Sv38!y2gblF^6*aGNIw*)$yIEtX+FzR2T8zJO_zkrlWK6`%DN}MPimfFJ7{+^rj1s1129H8$$|u0CIHBrrBx+DySaGVj`;+`- z;o}$+zPd-su~>4jvbKeIdI*v@?wh~!81=(Ea7qKl4RkR#zHvZBM`@f~ zT~Pmny#4tnDJs_qhd?!&LLJ1_r1d0h{g!p`*LqTBI7^9I+l`H!a_@;!E@7TB1Q|7f z$(t#`djgEru~H)M!Y}Y;WCCk;O_82rAowAe0*ZEAR$<7H69S?gDdz;L;iC#R%Vlmg zp&bUS+q>oyo_7KTCS%e*@0uHou*MKUh@V9w=p-E-NoG~#IxS*PEf_;d#-f?s3q_IO z($O2h_xGnn8~yuH1!l0P%#C0*sM#f0?O!ANvAj6`Ge^*sq{yYabq4ge(9pYgx9Y7| zd%)@CoR^pgIW~q3!G?Di#Y&WmoCrf^k0Nmu#R|uT7I_|Ho@FbVD}~WBN5#gB$TRj4 zpLC4PFDeHYHQ#Y1ENeUsK5f5-4Q4C-WOO_M6`ycqFoNLaR@^bl%m+uN&m?{;-`a4> zK|;vIs0E`zw z+(rq;izHTehI1fM9U)gAal}801&Q7_Cy6HT#0ZUxbx{yuq$b2A;`&B}`zJ_P!3P5u zbhy7R@nOMHE&+%MSKO>Y(0+>&u?{2%FYry7(#yhN7zDJXtfjVb#?(;XhczP*05D31 z3~4|A-T2fOxCAwdX+Wv*KnxH!ex2TIZAuld@)$Q#Ge^6g{3;J3`W*#0v4IR!X2D2J zv%8ON@UNwp*Lr?P(5wN~bODAN){w1tbH`sl+$!+#H{TITQHaHJ3x-p+<~acmZ(@+{ z2fV|vty(3cAx!S>d|0+cn1h=iBi%IW?*kDPf6gn@jf|};y*^@JNYf- zwo|y>ZRo(>1s(An>#FhwlpoNVR+w-Rt%2u;bn1Kv3;)+IBE#ft>8ytoZ1(xKVE=<4 z9_;^HI6e6+;@&<(DeGcY4DrC`FdOCSl3N5sLQV6|CW5ejxqlRpVCj|@RuLHnyVgpE z0g6ByKBh1M@>()bK}xo22im#TX!pI_k+uvV!7xH8I#QSq4#SVa3yH1HWiMpGxgD1K z#}Jm}B_=u~G_B=ELI@B8!@;)+j;y=Swuglxuby8-B>wTEqknFMMg#)-wt=$uO{t2b z`cxI9q*R8c@E;`+@i^sg8)Oj=bzuZK2Ia6^`n~dA$&PmbuZBf7_#&msKT=&FdMvz~ zY@S7F6$u6=1+#1o@zzJiN^jQ&iBZS9Qe4X(hAh@B+s2F`7A3(l_XQL<*sNe@%xDP) zZ8?Hx|^Y|C|x6U2@D4ZWbd)pmIJ2gKj#$i2T6c&Kh~;dRW#C>*}+Wk4d@zf)^d zxzs&HHPIgZd~YZFbIBv64CaWlXJkAWFl33AcbpnVbpEjjsQa9pcAJDu2P@(qWz%FC z*tp5#ty2p}xPq+DH{Oq9QF7JXYB}Yn92)g~s!eXKW4muLvK9CV`d(#X+%LvkJD+IA zk(_Qdon??UU86)2^q~-C!0oR@MHdprFNiYuH0?MT9cMWAXQ_EQYT$(cTE!pXZ4)bt z+jx%K(d@5InX*WjMVkwYW3(*au+3#laV{H*+dTab9%IY^hPzY*7(mX`$CP0fQ*ltD zF`PUe$K^Hs-%#h2Slj{lZ>-}gD4yt{@MxN`NKqppn^|gD{*m#~J(Xdbde&yvW?Mc2 z|6%z}tg~eJML+C&uH|j`nHCFbIV8(WotUt6at?A*GE#)Xdm{@C2!r7~gy5V79ugH5 z1@|a$co>CG(Fj!xCE&9ePBD;)y(mkp(#m~W5AZx-;xTngA^q874<;f$xlG`L86nO7 zcTyUG*{D)D0hGw}v}u*>FERVkETfkm2DOLcQ4}CxH0l&#AIoc~aI}ac!Z% zw|c(|-a+&Q(R7x!gFUf={Ly?5bGTONT!zgPDYs z?~5BGP*`z?0C<~Z71*+1E`=?U5V!!tYFUYHeT?_rrycHLcgjGnZ>%H&p;H%S8tcf= z-blVbF+9bJzbxFJZE}6aTPpuhyeyZutK$A~+!*ewN8b#fe~jL=ygV1oVnG|5%W}iG z{dA<)`Sk=;A0XVV1Pn(|FS>A8SS6)`>bi2s`4gxC01aGUy*vM-Z$GjtGnzKt^ncw= z-cyI}9^-lapFNYE$RichA(yOV)vI8B8x6g;TP8zmtFvZFtwGl27>Q)Z$shm)otRGS8`(sZ!+LmWoYqtwvRnnd-iX3|Au!i9W)vpQlD2hcS%fFiZT zfsSO7BG5Wi)cyqP`qdfXjdaI6bLWCY*T3wJQsDC*y@+iHS^ zt<3hHe25@&>O4-2vZty<+V7Y@&piR*e=_O+9(;c97@*>eWaB85gp+DNQOWtrV@Wy6 zt|VNB1+5l+5fReZAP2VFSwyeYj0ndsGLE$S6)jKhXJx%TmD>l{^FE(84-{lvAN3kP zEhDu2uZGgeKMf^A2*GR`T zp~C_<=RY$?Wt5LFDv?QK+dthTT!!>O18^I-g8G@1-bdH}(lf5<4a{OM|H~TQ7-Z!#c4ON?wu>ZKB;6Pm`Zo_u?(_M3M;P@0fHvX2yHo(0Sdu- zCFXu-aQl81Lz%Gk4l5!YSLfmozgT+(!F)ek%D5&v%|ePekXO)%eqF zM!<)pzQua_`c&K%r=O-EcJNvS!+d6dnxY&rghA#_#mjIJzPWL;12$y`_OoPa#Te|A zDEJ>$-~4(7H^wOJ6#jUIgl>g39Z{=5#`AIDcq;8VsI)ZsK<{mdYYE11t6$;xbTgJ} z4x2!5;fkA_jG;w5TOLOqN0epa>mrGlHQM%nSlOfM3%4wtSamQcy2TpDklDhJA%%BC ztXK@uh##(msBby8;3h*WZ@=qoa!_0=MNK<}L+Xs|8!Qng!B_3i1eJY&cNIeh8jKMt zMDCw0!C2q1nytt6e&$1wk5+WYs=t_D^G`QBWOKZ(p|Si>4?9&S$nvE*jp+-auNf$G zamC2wiSJNcW^^GG0blYNB1EYQO>ct<{xo|_9yL;Ep__9!yu06}iJUi{TrrAKZl1@8`d#N$e>cDUQB6QEEO@9d?*; zY?37n>6{-wwKrNa+~-Q+h!9YkVKpdE&IiLb8U%3a_^CEv7zt1#z7Q-ALSYS7^kzQw z>tFYH=y%(A-j>nvs+E%^KH6v2BGG>G$)J&@9)T@2pFqK3G2Jr2K*eb;phyZ;(~W8A zWVkfL6827LQCt#O@oTY*-z95D*|HMy_&Vu-7l0b5l2_KZ*sWnjM7en4#G}BA4@BAG zi76_8YS{=zXgov_p05yv1PQc?%I{~SpQJW;VHucz)-g?O;KR3tKOkKCA?L|YYiZi# z%@Kje?=C4*Z}(Y48osS^s#gEb{F0v|^}~nW{*bT_7pmX(Zxa*kO)p=K7iCP3xCp0w zz<}V9I7?Xyel^Ai>(z1a_`+163u0c62Y|f?VPjP^ZwKpo;>g`9ZK*AzKZ3g0RJ{Ka zIQibcm050=P7&^v9zrgqB`1`5rhuLHbiFGMj;o)+6rw`-g4|M@|NFR*UB*h2JNKhj zRy9??>cfbu@Pj}D2@90pXZn?AC8603v3pZltptW4Hn);tJ?+4-`I*ae>?+}`uA$3? z)+3ZhGX~T<7yB2>?PFVJ9mTz~HyJ%Xa*T@(FL6!kTQhe}XFcOy?ekT6|jed}6ozM-VDacrwOEX%F zWhGxJV`rV^DB=4i%RCbH^T|$wA>&n7q%S28E2H~!b|5nV)5*a*n^Yd;sc#_%c#oyJ znk#o8j&9!<&-PewwdI5g&h~)05hJp77Mj$B?41BF{14k*-Gw${(aP#fwrKX~_UNuP zCW1laRXdCN(qUmA@{y7e0x59}mPw9xsm9BG__;}n^8B2ue?k&uYlIQyz-KO{&nPI( z5_nBe{K~lqAaDz>btx*?wDrDvBy*du= z0629d|LF7crqr=2<{k3QM^bat=+>i38!YJ}0_^7=ccZ z6dr{sw*&Mhd9}#i zb}O~oMsJdf5z6{0C`CA~jcFsNyIX~ENWjA8|I%z#>3IiSz7{=-E@`}4cQc&=HbhM> zD;z>UbrL2s61{x+O)x&I`xivhGoK|ST(^z9v{UaDMBKmwQVb*H7k`hxBz=xd+T~d@ za9rOmMiq4yF?#B(POEWx%Y#()cDlAF(R%9>v*$tLlD6@2|Mx}Ndjsq-^`CO3cWWu& zaQBpvnBi=Gn0sevc2OU2+F5hj>8pu!H@P`%ahpA{sPlQKVS7E&!u&ET8H?3k*@37l;KzUM6^_te7;I>#s32Vk~jMrOu5WDF1 zLx>$8-2M4B{CMz+BQ69lpTG0^OIlK*4qZ8n?%Iv5UI}7@?DR=-dXNb` z9j+o}B}4HoJrs+dn^ojC?Wac{%}W9BSbSiEw-z0}# z5cdPEUy0AamN5G9<5*olVnd>xX(Q7Zwi>QofsW6PC`N65HnVwsZ7PzfdehYeT;6Q; zA|wM9Dr2t#W553VS?aiU^uV}@hc`jieCNthgcS(2Tq(|3-Ba|XH+GNwsrmRzQ_GJm z-Qopl9mp9*4-d|W&3O^iWuGq~?U*ZPT&K&l3e=&&UwrWoWieHWC32~_(92_BR zAZCrcr)e2fA5`Bd-7EdjmACJ-wabSz(;R1Su;LMG!Ze8KWvu-{LO#cY3Z4f{fDrd=kl_`eY- zjQY{!WAkT~kQ%_zjubX#Ab1w}C5uCKbPP!nh>J@@7NSHp7Uac_Ma%gCv}}bKnL3}k z!9&Wb?~#0}FHBX&VkaD;b+>t90Uv+KWM>wkLx-dN?Og3WqEt}_@qmdTX)!r~u9AO` zm<AkM&cG%UFo8eU#fvT)TH9NmIOFxb80&hjxUnKx3Hl(wgH@62mKe z@l_VraTy!AR~^{m*=WapG~*0&738WbyyG7|aJ~q}$p^$Zim&vqZ4w=@{Wj&_QSa-c z&B~hpXpR@E7EAooGPiFM7+7)(hK`U|Yz}dx} z54SKo={FBFK)wYmVpreVb+e8)G9u_)o8Qlrc-?C>HcG)wjTeBG0;gV(O4lV4NV>b$X;iS|Cv$_i~= zJJkMues){C__BJBtM2nvB`y0CM^bAW!(n{uwa~e`jnKK^cYV3LTFSk-jt8uzY8-G? zNHF4;o1G<;p_X$=ePdTE0(V#YLSYk z4}FC1$DZw7Pu&+jvo>$vbMge7_jPwgn|)&dUy1(5m1;*=vmU=_PmxXgfs^)=Jw?+S zQ>vR%kDR6~9G05Uu&-a<%(hSOame=pKB+r+G}iySp;G(92bFEGmyb=p{961{v)ywo znsKZ?_|9Ro@O|W^QHE`m&eZ2$^YdFYjr(uaUxchK-{9hgqP4mv^I_`8`zjQx8@c?7aXE@AT6^ytNKRjjnt@QCY@RlzfQh2gAIBrKP!J6 zb0UQn;WX*0%@ZtrYXy|q&lI02q`NV!P(4s5k@4~~>0!G`{QVRqZ@`29nF2+ZxJ6L7 zA4Omx23ugF)F7Qz9G?QkIV}lAtpQLt%{TETlUD4tz{l&19OrBMq-bo~SXZ?d6dq&0 zrrOQcu8OWIoBIY_)__V?;nS_s>n#Is#0-{Jv9XXW+-=3a*O#G-FII(pl}+%j8~C1{ z#AMa#`g+>@{Hfmba`e&0&H0w|m&Lsy)9(%DzsG7m-l(+CJYs1*Oi(-bzX+}ani`a8 z7RL>5#C~j>>e4RKy^GUkq-0(v9(wF93JuF#o#2P>JS$ArV%6^UUP@#O2*F^3LfCo? zi};|s4f|>A!HJL`op>e0T9~?+gQ1C#l|*ScXmaoK(5jwzJ8hr;zLZC2x7ZTQHEejC}vK8u(lk*)=LH-WE>*P z*n+I4D2TLNr#yX*M(%RnIkP!H!Os>Se;l13maajr*eU;h*DOaaM^3YnGB{CM>HV$` zS3#IZM+7k+rUYgnzZG!=anhT|3Mc5P8sAPd^5}f>iR?bH#(ORF12lXQ_IBP%#Q$u9 z2y>0qmPS{JHSw=~X0;?{BNDK%PK=T+MKdkb!%GK$5<+nZF^$A^SOs2n&x_l)kPrng zX{Lt;<;q=;V-kxIulx*m@_zkuZR~#RqrBC{%cFKDVX%JVB9C`%$*Sp}Q%nHK-riBO zkK`+HkKUK(;q7G4{+{%a(}ew|b@=QwJ{FQNM-~J)dp^AZH*TfAfAhn<;;~oib;6Q( zjn@35H>V!p#%duAKOJ9*1Eb8>3A-+*a$%81h8fx>dt%`;o?peA+4*5-VzOyDS7>(r zwV=)dXB?@H0H>Gxkzoqly&4hd2~a5Bb?6DOrI&thrq~mp7xqkQ_e{B5QZFu%$v=qh zL6NkmrXJk`g=IH(5>^rg%yZ05{`glbZ2>xFQRRN+bbCK6AH z6a-YwCYJj7Y6$E5Yx!$QAu1wh`z!h9)5#(sYWwH=`AR;HBhF`XIwWQVh;NB=#-mr= znkdeZohv5gmot@mjYE zy@OZj51%3>xx-k!TDyp!R4?fA;xzMVeV*qhYEFyfRqabj=g7h_4Olh1@mdKZIxvD? zb{HR&8lxF0W6f<8+ldpRdn+ke&hm*L)p`B@{l4|MXc z=#OSOVGLek*4o`O8KZl8&#&|dF)^U2RLX~86pW0-%8y^X9mdB%K?{ZjEW?#hIkMu^ zSvAHVby4ztVp%6T!ng=3)I15NM5n<{8zfrC^;O{qSV?u?KEVG%# zekjl+^BU6QGjvP!+w4_hmF`8y=sCiB13-e7-`B%rtR2te)ce6xViF&PoB5|Lbw19K zFuxZ}koKL3!~*vue1rDkP0*1nVve-;Uu&=}YgGB6@%F#QGpZy(04xaii|2@$FVvId z%|Dvdd_*HunHHnCtH7SY0}GfpKbPfu?w+_FD;cC8oFNc++4xZ zfv5MkENnEdM%;tG0Kkd(6oJ!CGNqclh|guBjD*+YrY--B-}X4M)d0`s(;jd!xXEg5 z{$clEXvX(OSL5j}Svlcz#NvEIBO}OioPyYs`ldXi@0^in`m4B~sgc;mCocAE()!Gr z6_RkucxSI#^DG9(6Sm*~{`sMTck@)vpJ}QW|1RWi+q!CPmO`<4?i!MJmdJ69wT24Ll z^*!3|gth~)@C5A&VT<5g*jjEh&P_d><@`AJM0 zr_=10NQXdkPvDR;hm7`$EHWc{@if#Eif_%>63^64`E1X#8u<(4Sur!XM}*EQ?gG6U z8z;h}e5P6>vBOVU1@%Vx&klF$S&YucgyS7ZWxq=oD6o!H2)$>n zWImW_g5{-AZs zMQ#psenVR@;SyakKU_XhL8TjhVKph9tXnk|B`62wVu#zIC9i1h~N8J_z8fLaFz{tuI0uHSX3+fpS68A<7#Wkj_@- z3iL+wdgmqx91FFP_4UYxs7yz2H%dL7aehztXGFjVpUVr<`7zTS%h8{+Dp*eE1Jt@O zjE7||fC=Jk-V3FuhH|b)MdrVClQWiuVli-iBef#K^2YLxG!`dtLEsu(+FgdsBMupv zVMRkiUOdCNjH4bJ`}|7TZjPe9kpgqn!(Il&YsQisPJ=!dl}@ zrv~7dIVgYM3^Ou|w9hPoisn@XZXZaC6WlL)s1eLL2^)5m z%?>ULR@SJ?O7=T8VbITJ(@T$vJL~B++7}c>)Gj zAtcs?mBw<*QYh8ZlEcB6pQM8gVFoMpYT6|1E{KKflEL}T{9BTe!R(6h8h}3nfv*iA zNf@Srl%AAc4q|SX-C@NwcfkqQ})mZ>IHu)DzC&Wa_ zul>%p+R5725^18*D)rs-yR@G!oc!FN0czMD{9ZP4GdXT|XZyA`wCGs2*go|6p>PD* zBcl^NhnIP8R}gPDE_-bTp4~Z)O^vfMP4)Gc!Nu3q%FaIP6UL72bh&jd;7Cx;p5EqZcLllhn+@)V z7L3Ryoj3CMcQh;Ux2Ph3ywU=q5{&go9TGojdYk1P>u5M?8GjBG%qDel`emvm#%>V1aC3m=xgd$bFN1V#?6 z3Ojg2B2H&DK~!4D&n#+|<`*6Hxf~AHEF&i`?$RTOJfPCqguMCJnFTzmhiW{OGCc ztZF`Qnl<$`*)3RE+Fl*u=C>N`Ji(f?tlk&C7}%b(73Vlr<~Z#HejAruPGsL$x$W;c zRR{@xf2028$1l0ow6CZVpJ|g$n?4Bq9_-qDLWO(!7|+M1$KvyMJ>*YIt!+CY1_rnj zINC6TPuY|@f%fpXuQhN=bn!pET@Hc|jYIS0bRu84Gn5qQM2Fielpp0%CTAB1e{N8~ zDehsbQ{XH>yRRiAZ-D~a(4|PEg~%}O)OS>$>?0tfta<| zM-u*q#88|fyUT7nWWk#0r!yDC8I#I!bVM0rofj&$&2PyIzz1_(8ctB7nAwKoO-;cV=nd2 zxALF(*H!vl`<{Jsf^Qn`9SUbuui~{a0khDr?ChVGQuf6D|0@gaZ{A-|gxmJsjMjB+ z_3Vo`)$e3^rti${eu;->eYN-0r{-+MaqZDOL`jz+|U zvUN{#Nk#bKqfKc8QmN<~nN8F|;fW9lGsrXldqf45O;=3j5ERtpR5Ld-j1lT55Dm>u zS9F!`hg;_1Z5_xa(iW^H5Tpc|bFHU{NB zXaKZS^xQmu3?B2RB&lKZBqeYpWqf8!ZVaNJaQu$pHT3#6Inzm|RBBW^e$iBF-As87 zZh|twZ{~MNPu@NL>HFr@yB~elt#!?F6^44Np(MLe$yG0!Lu%BLy{>c)*TypV^jAam z`LS>AyT^{cZ5!Ql+H-WaY)Jmd{n%u9HkQk})bsecYxB}mV=CQZw1*6 zQ51nW-#kIQCQ}0|MO~p_A%Z201qdp_Uq`N&N%R6gW?4qgr0XT$XOvQlQ}e@^zu%8R zFvKZpt}a3^PNGs1h|eGhK0KQRPvg;*WR4w%Q4Jb`Sm;DPULMhA1oHw%&HzSjP>_{N z0ue+jU;v|&cVz@Gfhf835%}H1Z_I))I6{vX-BR%hh{7;f{Zlo90SUB3KSIPk!x)+A zfk+9g4_GfgXi(`oL6jKb#Es1w^F4P3_%bhk^*A~u3BTmcpL02Q z=`7MDB~0}w<3z7HZDo&GtOy(P>KF68E{?h|9s;JM|8ZnF!mtM2-X0?+9YXFsO+QvY z&==`f&5&Wg%C6j-EibDa0XzbfK_x#1<{o*9+j@cvb;on0f zMxg7UiX%-VO(dX0XQW4ORQG-=zI?&0B%tWW+d-~S+LT16K_RvLL#g%)ewIc2?f*!< z;O{;sPNQL}mzHzzW9%q8uYcB4+evre-Z3+sNDLdL5G( z8*%7&*;a+xesi%{Wq9ch?rG67A9>GVUVMIQ&xdvSzP5N~oGrx3ToI8z(?a@ca%Q6Oam6#Eo6_VVBr zz$?jU0cl5{!(~9I<-Tu)C1#w&wxZmVI^!pf#P+}yy|+Rfhs)n+clP2ac&){Dv@38e znsM7W-Ie((O*SC#0GtyQfyL(7t>3cd>My-XNMNW8y}3ff#FSamDoD699Rx1TJdJ~;y(2fhDR|p zAaF8)JBi4VHcB4tMZKsZ0dxfRf&rlPMjhcPSI6TetZYykYwJI!jPijj=yUy6HyG76biTjDUPH(jYBL$kOW?wbsHZF`hyzs zcvOGb*w6~41D-I(Jv3bzL!y%ph(i!EfAN0j3mY+wU+}fkQ*>rHlv(N`_qcy@u7a2V zJ(6Kf%$w$Ts4;SBanl#bv8p@uKCB94v{PS00z1z?&|OAns^TU<>R1Oa5E*9o&E7Dq#*Mh*m>50Qap1uZQ1vZB;&BPHOF~&n&yOwA2eyx>1y!z4;GVKr2Zoun}AUY7-08bIa}Fln($f4suESVpIxO!QHJKhq4t`seZ8?0=WVlcubg2Jby!58*(G}Lu z-@^|Fe{WA5=1k_#%!%KYMXx!bHLZ){~8JSgpE3l!^@Bvqty2y8YqT^%&dJf3aRN3gc#s^+X z$na{FH&|{XpIXeTp*z@mzZl`c6!|v7gFFh%$#jH>taBJZWv$nXe=Sq_W~6~33s~Jl zhNW_yBQk_q^ojNQfU?dQl`ue`_VbM;Y=h&ua8VGg9O*->f$toKA|w&;v~CuR957=~ zl%1M#>>voty;FK~lf_q9W%1M&ETaLQDyOPV29g>(#O72_D9YYI@5hBbRE?gKyXaTN zPhc6Mi3ksshbE39CS-)36HE*6S4 zcG`@^P&t)gr`03}TZ&^$rml@2p$L6yuG3Qz5fYK`a$T9Bx~=* zuz9$eMTPF{UH`#yKv&l8xc=D7cV(B!pU-Y}{*X2d(VtRn8-HzQZu=$0w2J$!Q1JGD z$CN7OzpN~(j(%B{R2^O|C)m1$N6Q1NKlDCXxK;U9A(9I9&-tHhJC>m2ma!^Txd`$} za8ao`pY3qtz6{7d{Bhm!<(E`hD_CG#br0CL0rsk!PHRZ#iccY_{(K3xce7B3I%qd1 z+H_NMT}32ve_0(&-lh{eFEyZA=ZbF+jKl~PrROUMffpT7*f-AaEoc~t3HEfeB1smv zl4?qM9yDf&k5jf5J)_F&FiF8818x+hXWV{9eik_8Tq<_)<-~<#87_kKDS#v&ctnI9 z#$c}%Ai73(wY$3}!M86VfLrmp(CRKKWL$@YKhC3CeXzi4WWbIui;DMa){ELH@2bJs z-BTwMtEkjs-IcdNMg0B8d^I*2gOte%A|%5F$)S|6}lUCJzQ2cUy>#H zY>qp8nWpfPp*@DWRh4}afGx&g1{HsR)d)uvkFo%}k4mQQl#MJuee!KBI%z%?l%C{` zVGHZKFUi?HWlMflQOUB(vO4EeNfi)%GRD!-r3?1x-^N)~qY)_^Y$(Z7?AoZa0+dE4 z6!X;-f=xlcraqjBsbdw04}>(IeU2XVeCb}5cD*RSlLVMPcjX&g89->=5vdYpSK>9d z!soupf21?H$8`@MztrAulZNa1L|k<^I$DmK?43p{OB33n&w;R&Gg9Y zlcBzEKefRp;WBZ-)qS-l-NB*izhJeq0L>mn_`^ey8G)F1g2VQ6Pye20HqoOGvPZ|4zSAU41aXs;+j$I(I<2P0UC6w8V65Rwj- z?E7Cmju$XnIu&@RFTQV*?57^S2eQzFRPkj2@x`mNz3x3>XaH?m)N3tSt?+C*AT+f0k_$zh3)(CS5`gS0SQ{UeVYL%A&~Cz4z`oW~bg z3>}r4SbozB2G=iRhmw--OI2gRI1is>$T*$BeC5}jP&pNiofX0feUUjqInYsvt_`6i zxkxDaETJTBGW4PJ7VBV^OAXR0wg*V2$BmPLh!u-S55ZOWa>$+XWVUVT+H|k8_?}3` z1jUk%AgDX;_>+&o%|2r3N$Z=4;ARD_5(Wr|f_?ci%(oJZjt-u45MdRoQDPZV{zUoo z@e^`}@anW@BDf;BCUn+xtyDEq;kq##h_vgNAV>1PzD|bl-ZjFn9AGB_)FDDE}Pj7IYRwTl;bq89HhlN2wYdac)KaG7{x59YPL8G7dqS0b?6HOp1i= zs8?>`!wSHv&%@uo^M6OR;VZtCB_}ug@6Ho%$fHA=UIWMP6v&0jESxXv7v`BSx^I5B z_e~kFdmRdi`8;Z<2KK~XmASj!-I>_3Bd^;|odH2uOtMmr1mD-s4ub9)oPT;Az^)eX zGS=2%yEBCtFW``~y@rSKUXx;m38V1Tj1oA?9D*4s(E}D^$WE+les9d9{%P2&b3EC+AnY zqvrf4AWr}lwIf1sN>64$r{I}-O11JEtU^!GoC~E#q=Y{msi@QxC~~mG+qM(=liwq< zAxc@BrMrJSKzbp%gq#+fU&uLa{bj;6vx2t?vt+PdB-uz-%MW?2h6Hj^jAR`NBvixn zawNL80YW#d$`KfXqa)tN9+@Fi{DZbKLwAIuI(>}eSJe|5p%2NCH5cww&S`hM!_!JU zi)tFxhllOss!+&@Q?2y2#TV4-;;i&?o(234M#l)xRWl*FbSM!Cw8|9esxM}yPJnWP zqf+&;4H1-+KcrXJ247+Q-GLMKQwx8NFY`OIK#a-O%M9ql!22EelH}Vl&EuXT;V=uy zN*Fj`h}miw!fjVMBB~aH7|IJ3z)=zh?L&ZvIw=j}I0VD~{!_9t25fGDPOkTql{{Ft zUZCsIW^)WFty43hi8`wc(!?}gW>S~@7L}REShx_J-pY0h-r4Qe1>H2Dp2N2V^xXrG ztRKH5rLFEeKKy4O)%bN2Y)v*8_YUnS4o&0#dP^+?oEAP~(z)EX4c7Lcy+vn?VDodc zQ}ey{oFT@(jfrKn3x&WZr9C$rU;QJCYPo-)n6*N*XuEHAk57L_ts1>KT;0tZd;fFn zH5=!rHVj}Ah1vwoPR&&?k;>ee$`S*c#i~5@5ejiZobP;Bv@?-r7QlOL7 z(NaKDK+E#SfM%hNW;9x~sbo-K zb4C&=R1HY#{JZSUZl7*#HHlz>>z)`Us_J5>v=VyyEqNu4mF^%1LPV+zlC8iBwyd-j0@GW*!7a&R$oMOmNX6F-1(u_Za4O-}kksPOk8~lAcWpR`+za%K=B4kFA zblo1Ydq`nEK4Bv`A^H!GreF~xOovR`MNyDc?hC~sHCmQ7a9nm|UC(_1zkd)S*uE)2 zQjD*KnOt!FHDRy~f{)6bFxv*n2gW+251SVjX2dslw{P+%BfbX^hY7J=*L=Sj`-9;< zn%O3QUm$)s#ECO)(SQ06ikG}};PB|7Iqr0W;i&GKs+jLQ<;BKV3^lRS;QSPcb{Ze) z(M#7C8&5|Kbh!*iIX{KE+;JakSHi2)T~&UvJ2$xu5gK?B&Rw4>hoJsBYbPu^c%Q zuw@nUm#hf`L3&n@tXXAwZ1>jf=$~7zSJykJ=f*@)<=m89RU0O@n>c^H!rF5)$WCQ+ z3EcsRL$PF>MhR21ElLSXL0wmNwB^ zB8x(-)skpwzP`#q)wVa})(7na1OYQ39q~g7H+QU{h^6 zKPnzHt2Vqu)T%J5uC@X6DhpNndc1`0kDt5;Yy=Qs_rlevP7{gZzx4tJR(?tSiRWDA zIEMx17QDQUNoSU;39 z_7xKp5*WSg-*UYLxWGToLo8P+Z8u_qE!6tsb`1S3%Q+@$$PG4Yyk6cLB~z;_<|hQ`Rh10` z_mz_$bdq6tQnheQI7b?h7fUbl8h}SFR$}!las^nf@H$a7aC`}fGO%*f-EXe;&?V&X zx-WK2d+8#{MW4_;UAt0g!U#!##`N^;1Bpxzxc-7dCx2oSvKQPy{*x=Oxv;-QI z>m&5Y?Wv#j7g&y0#$giV{K^Rce}bezoPMNbVZ4E6@E0{IHa;~i=G7NaUXe;mNipRq zUW4O>8?i^?kLRh4u2n0vHz};YM^A0}xU|eoU|j9ZUE3@e>?H;S>~6ex-ReHxY1#gz z%uaVwF74$5mEJbXZg8j0n2BL>;IWUM@oAYd?|LP84?45E%WiysZz>MF<-9dqjo3LY zdk0;%)3&ahct)jmaDyPL;#W$XxLR-%-LuFu#}=kzU)bEpWi3rPl(Q{wu{4s@CApkjO)eU zK?b4$yLBG7#2)bf#O#5@-e!9GuFu9$)$Cx;^i@+tiF39`Mb-1yHCjTOR9yQ@wAs+42PUr>%h z-UiW;W*upR!*#~LV1`e6G6AJ99dt8Ogv_FzWVyU_c|i~{hnYCa23h^`)NdSFtWuM} z#juRwM+QWJ?7d_wI6ARWu5zUX7N5X4#5i{7gRFh-2W-z9Q%dEhU^`(3aQM z+IEPg}CGw_1dAVK7*z*0D5sui3C{}&Qw_I z>*It6O>owfh4rukO;eX3JDI6&gq~zcuUbhPS$)=aOB8z+Cr<-Jt5=J%1{>_ow{)Fe zbZmJtQON=_gP1@?&Kh_U^F0c5EzSOEdM!eBBzRsk8DdRSJ1B0BqNZdq?9Yc;WaaR) zs_HH)(&7;S3tnDG6bOZvD-`zzvCU#h6^&pJuVXx`Do1CpPNX6mHNET3)2CEyL&)3LCxIxJNAd$zwy^}$0HAmZhY;EXh;`a zYxg(4o_7F0>$Fur?QP$z9SHbbttZ$1r%b@ZaGOGW=eYGZCUBHL9+aX@ejTf1%HlKo zdFEl7wPk}#TK*{{?tRN^I^B9U)ION5=rF&$7FQf6RIYL|_yL?g4*Kk&0<6;EIV6^@ z(w114GgzLSn%KqyS!}DzQp*Te(ovAJKyq}?h4so?gpP8D;>AFppcCJotrvo#%c;Ei z;FvzrS^=(fx*y(4s9Ww6-s>A(*ZBnkMJ1(8ThVklUm?u@7kkhwPDq&Thlo>nkycu? z&`P*@*V()bxIVE5s*B66e>WyP7=XCp&Z*6}X8@kJm!D8M0C|j)cT_yz9A`SbX`FCA z0OW5%48%SV>r!p@V#lVT*@)JKIsfXuO5hJd+b$JJIq$DB*Mn@&Vv}KwUI1 zE^c3=JyUYr;~Ku=cCuXj;GTg2d47ad9m~a4((v79+&`}V3RRvfy}B-sO1lUGm53|F zkMg3uvc<2*S*zH6Jp?-A0|RzPr@n4={*fC_mHgcASEV>SNITC@;a|9V!#kZp+h~nx z+!Ufp8&f}>KUHko2MVWs4Z#8;4m!GAKDJf|P+kd)UKA==fa2Ts0rZr9hKD8+yvWW< zh5)1h!a^<1LJb#A)#V$gj^`(N_rz|W*iZ7kri=*+Ufg6lIvN6%E9QYmyvPKj1)hdT zOeiIiQhNRa9HR||5(VwH(KjOt0&EO_p^t&6^mJ8$sO^4$Nens#7Uc-8gJfVlIx3n$ zo4g6bB7)S1>kQ%~X{+Pl+;EsmkN1hdGs%G9fLX6S)!pL8!dLQe#pDQW*ZvWuDutNG zqZE59?Wc^qwg>+QUDb{~@(W6LiZT75o_EhECJ3WzW*jwk602DNc%-|5Z6xSn{841+ zVd!k!=~x3KyNC=`i}dJ-TvZ;iee_N=)vf?xG0Aj!*gFUqAH9+C?TFN<*sMI2maa38 zPobX>-{b#Y)u*?FEk5K|vSidE6WRMeOYNXA2@zi`yihceFu zSgbTV5B4jWb%a{eRHsD+$^9F-g^qwlKyifkO~TX*ixJKhp89KP*ffFA<}_~y#@ac(MfU+>u07OlF?7F$?*1FR40 zUW#mOhkjT=d+obRN`JHZ9`CCkGjK0;-e6Pcu!F{XE+sBXnB~)!ovC%zr(?$&-O=}k zo)(q_$0>7PclW(c95yySKivDP($Eb7UP;m}lw2fOKT~X5H)d~Cpw%Dc?p&zD2pJXt z#AfcCPa__W{@7SK+CDw#_P%CP(z>iMLId(}3}9WX)}hC~8#d@u?bA2e^&GNsIE-XAm)s>Kgq5iGE`3ziXuPMEd> zrgX$)!W>;63Gi_-S}<5}@o}dsiae5Cbw*5M2OKc0q1Hk20^fD%w0s=29JH|1$d&DR z8~W7S8L98mrII0Lu``LX>{uMMkY9|YI4?&5CO4S_-Lt<-)CK{+g|@WMCy@Z*fSew)A(+)? zrYm6=3~T_y@j>k_PAIEf%u;~qmUeW2$YxLe#FR<>iRG7)`noa;-cQ$s(J&y7qxEtz zFTr>wH{sLWMU&PuQU+fmj_ws>J9lSmuk1L0`A3F9ecC0)x1~W$1?wAI<%5Y@qEMVu zSjA?*6C`N83rE^C3Bt1O`<6a@AC!*nNoh=dh#<5kyn>xe9t8vz^h6NKV$oapT5m88 z!78lv=PBO*9VB!431QzLw45(Kgz_QzkQ`bTELH)+h{TMGHP!M$=?q3gaU{Kb>f37H z7)6Yb>PGRwEqm5J=G$m*@RLXYOCorene(%-(FnhhCiWK>%D{cq zPKpMNTARu>FLvtOTRDpFL=8n>;IjAQwp@3Z+=xFi&x=SJD(L5~6cB(F_u1H`AhD!e|IvV?p zaOv5f`Qqy+I4cV>sxFVNEjJC~M{#e%FRt)ioH?>6SR=cU1?<(k3Y9v>hUyeSer;)C ze~$OQ+{V1tqR&z$$zo6PcX6zPjEzbN@WWaXS_dGMfcA^x-KAyV=I}T-3rUgRzV!uY zi7a)Wna;RrIh|iNHon?&tysgyZ_LkcxuR);Px3_=64l&&$S%yzAXPgA{zM9PYI9_E z&|1W9*a179{c9djA7nfJK{v%Uv~C7=k8Bdh+;Yj=)^PFZKT1U=GU1w&8-fxg`#Sl)*%O>*37c0fr&jJzqTp%lr~>J4{O*(em)J?+iG^>Da{tcFrSo5IRw?-4X|M(|~eGyi%w8 zvN`#gB=UWY)D&GrU9OZ?vu+Q6q+O-WylHp;xhh%zbMp<4+q65N*PD0c#Pxg3gha#7|hqPM0>CF{b*SCcL5sxP# z%e?ZPOZJcat^ZY6I%S#_YI&Xf51n=7migV75=0oq8o(qaO+OqpR5m!NwHgr-o9)jh z&`kLKKgs4;WPxEoU=k>{EI?lEXFnTZ<$)dsoT+=BS^AoUc_$&1+s|Roa?B?Bo@o-Y z+WH@oZipRpv1Y+Q%0I7-G*L>H<)^Ex{|=gQx+EungWH9_V|iuOWVU zPc??*_E&l2)z6ckgkklBa0LCa?ghS+ej9p~FB3vQGMr7FQbjVCrAdcUB{P!0%9{y1 zx8<6A5$TGUXf&zSEKhq20;xf%?=Tz+^)zQXCyyKTVQ$JX8#h#J~j6x2t84S=?_}S=^3yIsI8yy7A+}^+z+P{mT0z)$u+* z3e0dFS#kM9Z_wY7A5%Z&)K0RGpifQSu8U-79l^0GZlfXL9fm7Lf&nzAU6yT zE#TrI%D(rqLW`0_UD(JdytrG6-+b%L$}ZF~>?NbLo~&I3;SYVJ3uhzPx)fS#@q+}2 zuW2K{?akBjUwV}XcZuFZeULguid92zknL*Wr9n02T4q7Np}~)Z5f6wq^fun17t2hH z1?zO{d&bX>q1DVXn>K3^;;K_*g%T{?@5<$IKME8jrabejS+>`y)Jm*0dB-}z`(=FR z>zJNec(JRy*y%ry@eg-0$j1Riryp@Ol*soF8VmF^Iq{c^ma_#5yQDZxIX{w*J4r@Q z>FE)6!i!@MxZ}RrrlsvsM2v5f1AW&6OA&hkFWf&wUcGcBD@l<_6(GKOtNhn(pZ{=U zbZP%A4hm|jnT#D;Oa9M{FL16E%ii*|X`uQ49ejEGo3t5(Ue0*kHDq-rDovMv|1#Y7 z+IY3mzPF6agUZx~o{0Qaj7Fkv0tSG}UB?sU=%#S=Gh!yG3Cs>@c!xCSJ07BoOu2+M z;tjzZK9O?ixJH069%M`^q|xJHN->NX(m28QbhFG@)NxZ2^OIeI)#9*$DrE6i^lsGwrn zEa6r&jc#J)fUa+h#$8B^dk_C>mB_t&QJZ(@;@@K-iKVf#(AD8Vcl#IQ7c;GjrPX2x z-@_C^RkbvuG-F2KB;z||*lRTeORSU>wE_&A!Ji>UIx%iw4r|@Mo{ChVTxgP-H(@(c zbLRCR@D3?K>_p5E>g0T@s&>38@NymY{NvRN+EwYl%e)?#aoe=4{R`?fP5Xz^{srZS z58IbOWYS5CNvUCdS+w@qVLqTcJ8kl zj{A2K$`&B60d8Gp%RO?J+f+C1bn6i9A`x=R|90-DpXz(>8*|tTy3Nqe*9-+`SHlVu z##6@fC2UaXa7S&?!B42KM1o_8oOWLoGFbR2O9|R870PmscSPvPb1qnqArx>& zPYM)pD+wj*3N*RnWGdy!`{JJh*x;LNH#$R+IA=XfBJNRwZp@~@RXhW(MbQ%PU0-Ux zN|Pak2rlVVPT0p#)9J6gcNV^ot6BKleIrInOth6xK70oYH^;6-*S)7NNH0%LXpyaf zV8zYjSf}GtOBi{HpLF4g-GU-w`CP*c6^1#N*AtVgrHs{!zETZcnV163d=IDvo4P;e zidV_p+zKD6k`6V$3v&@>e?(nn5tO%=?$%yZ( z{hWsQ|HwD33u|i_le<^+g3opvdYcbFu-+rau^`<|AdCpFE~Kk z;e@y(9FXrg2pKp6Osq2@xq=0U?)seJQgJ5lE?$i4jiW zoFIC&7-CC!YNe{-sJ8TABOO$B6KHWS8xwm46@;DPe+)_1pcb^Np%)}bxRYBd`yC^0 zmLv*_U}MXL#-V*W?{>C#TOMo)GltzaF$bBcO_ZEcg3(qsg>1 zo-d_D_t$omP=D)Os9^tV#Shq8-u`9#WS=^;PubE!C_k}AS>i9qdr93w}}rRN6jghuT}F{`ix9K${%MssVDvaGaE zNbS*$&1#SDFZ^pG#w$_p^Gm`8K&`9Hp(-M8)q?C_Gf5|819=KIQva zi?9)<;5TMDwVP7P$i7Vql65?@QQjCTIdJcjWnYR`C+@$G3${EP3#cb6@>|o5!fF4(+s zT_S96nGs(|I!MN`O$Q_f?>EXcfUhO#WP8lin6!~;f2M(SkIZdpP6ibQ%O6T+vboqm zHVA!zGqWUXJT#&*(F3CTu4VW@x*9q$jmn&OU)H<>`Q_cPk`hP?X%hEQWs<%>KsO~g=4p;bcy+Jo>GRfA`4aCeWODv zq!x&(tP|&|*ldk3eFRiA9YD^5x(H3BSEc@`X0#0zN%3Pa+i&h$)gLnZ-mRa!3;M}s z$}On>`pJ(%-&Dn=&E%%mJUeo{IlTV-G)dI)L@#&;x+eFq^~QJlQHs)?$9Iofl}opF zS8biM=g+F=N?(tsOqFc+oxBm;_N}00PB_XqEd{EAMqiT6ef%fuT%Y_uvd*U--DaIX zbNZWg-s9M;+wk?3R=g4|xt=#_4e010^wikTJMnB~q)L*O1QJ+7<--fe3NnamI-X-? zX`N+haegXry+}mUBO5Wc(UWIy$90$tkuM^Cp5TM5j?uz@N}&LR=Rm7hK=ae8p|N&W z(97>`dWzd>nK0g{Km5PYn965fj*|J&y6zoMFUMCr+gwKB>)`~~;oXBh_7|N^6H^YP zCPX*z_d!#?lod2|*Leru;c3&!TVioZy^wIoWEaB5Z+rh?Va?SF)uBf1>}s;&*`?Ow z){S=n=>h@1o+zV&r93;G9NG&yPCnL{c-cPKXZFZAF@?DJ4Pyq*IIXrr#A5|CRq zR=wsY^O+BdW|}+8WwcWmM#h+QTbQsA@i8qC@s7v5dJk;5hQj)E8yQ>`wB9dBx854D z=x3rY%jAYAn2S-us?1pT!^jyc!ob{+|rOKM8~r|KAb_zj7by{;TrwNf|CH+uKz! z@C5WXyh!MvIr24%5@Ek6?rQ`}gz25h6M3oOX2CS1-_#SaW@%wd$6~3EONEkF(E9M> zNVgxGc$Gi;0@PPLB9zIKmdt{w_o_22kHxZl#3Ze06A5!kcNdFhk)V_HXCZ`U#SBQ3 zBBglVO4G??etS|Bq7|+4*^*dBEmR7LkOJu9sR~A)?6C}kuMGKbhbW}Hq|;*ifx4vJ z@tL59D--)Jjr%Rtd*+C&47GQL9Q;ulER~9ua2#p%V_7-UQF5IW%nXw^lnK}@@}$qx zM0^^!D-v4E#39M{E>xjQVFj+s#qA1jvuQzK+K-#uLP=vu`#XQ8BdzKjh4p#BI6 z$qd3w6jJODA1ryZQGz6s;7Q4{R5b7;^svptz;yNVKym_=>||Le3$bVI1F&zGfkm>e z5ubXMi#%^GPdlGFzpOEQU1nJK(B7SU=+A@H@e_y~bu4^1d-veC=j^}YH09NR_uI4F zmTPXD);rWbvzR`ofOEcbmdCzlFefJFTy|Cd_aJv6_gbM!{r;td4_vE1ntsPdCLhu~ zqIxw(Fjo~&HrJU?AY-ue4cruZrGfZ$f^QSaeQ-*C@YePACsu>pCdJWFD<&q{I45ah z63b)9vZ1ol*_Xf=-!U+bLlm$pXszF&$Hes9zk7)hqbBnWAY$+f#F2u~`N#MX5qs*i z#KfrKCMn40UWYLt8Kf7o;n=enQiw&kJPP&!kGB1Tu0~>F2I9m!$<$cbfq{6Gk}&@$ zSPf-vjU+5{8>in+ezBp)t_`cbj)lrUB8CP&Yk>J^4H>u>Fu#=ZU~bewr<>2q5y+VPT3>icTO*Q{hZna%}76Q`6!pu9*3UPi!@=()X4< z=cDDz8;ZX9hfgGBwWs*?Ig_+bNn}ei>_ZL|xU6{QeMM_L#KY(@@<`O{{6+VF(}^wT zYcu>m?tAi1XZ;VI7*;=BI0fADiAD1*MRVBr?ESgMta{%5;MOFM+rYdkw8x1_7S4U= z9caHKGo&OQW9c#XVlwt&*6{q2+{UE(jY1<<=hYC~H_J%9z)`QcY) z1n5b;rhA{AwC=wyxqY9_vrXR*GbEW}E5HTlsO}0_SLI(uwFXi3 z-1{T=Hkj3D)2O0IXq^-0Pj0piiLX*l4FRKezs}@n{*>Qo*{=Xfs_h-BqK5hRGX7{R zqYW(_Zal%d(p=e!799UGf+^}F*fI@wc9EN~?iqP!st?Y}5b(A_O-OZZ6eg8sEJ%H~p6D zx-HqyY1ilTQ}Z^2BMJ6@BI{!?vewMH9(d@!dB5Rb&;8TqDqslGjvG4Nf zQiv**yyJ~oaNYAXZ%VxAlOd4ZJ>=LANn4$;1@n_r4Cb2>oD60srV@VaE{UOX%G1>iQ z@>|EFZL@x&bXR=0C6>XeQmNray^H|EZM|)SHQj`1%Pwi<;l_`f66vm{>8??r(YS_& z?{U8=E`lCz#fiKr-@3Qep@~PFXP#ya8enY*ubHeE%8o*?25;z46yN3BN_2hd+84}| zF_wetcfFwlqqZjEf* zWtp>Y@gA|`0rvN>R>#6df(iq2U)w&5cmXOk1v>7ENKsUWC(V8X^9+noslForLwsHG zXjs`CtXR|rt(RA7EP%#yjlDTOkjZKb!cFYrqNIN@H4+i~@h<&3#1Pa>8-8Z^%IcbF zDcz4%4>K&6VWFS{VpTek^2|S_#Mypk*?vL}K$jr;HWUxGvPiW-{r`lF#&N5CY=NEW zc+kMD>c&a3p;xOx0@Pt{??iEBah4B2>th;Xz%nbA;%o90>PraDEd4;Rn$uFa8rLa2 z&&D4to)pBPS&F3{$PRbTBoc6lC2v65gi$)9az!-o0IO0fa6fjlFW?3E%`AtB4DW{1~t|dP9ym11Hf}myp)=m`ZmaPTm+wu ztuKI8bGZrurVuXgzmx{vUG=?xMrzjeO8U?R?PJT{?yGRB`AeVE&%ow}LPh*xYWi^g z?vH;n>I&SSyRPaC7KS%8RJFwR>BV1hc!5go#AXoE{XO4Jk#70sQNL|_x@E=a_w0de zj?MWa7OyGusmL3VwZiR-jD$VcXmPR6vq@@=mj(XfA6H)1S|1mgjWZex%hL9 zKyS5z;@x7I2EPvT1l z9oNy09e7}P<;x(6degA`PY{p4H$b7n#f>#q$?!uXr6mTUg%b%O`()q~FY@&ohmt^Of|sbac+>wz_W zoF~r6qc29qfy+hKPR?E90SAV)zJt03Ew@|sZ;B}2%IbT&iE5X=(>cQ(LtU#_(6uG6 ze}Bc!%Z0UMgBrEe&(sxg`&^#J`b(Jvx9Au*_YLBYCjR9TIXKEEsm#%WSxP7L=$bY+8JZb5 z3M!iZY#QUS>N3(dPcASo0yHzP0yHH*_M)@V04o9@Ar^lO5k`L|#X*oDb_`Jin*Pe; zu9D}L`Nlq+WvF|PGu>bNM*-%4@<6X|Xh&lxIp1TJ=xXWn(}UwZV{cJy@p=h^W4mVe znkMtlUz|3a?ZUXnk(=L! z_{6IQ?_1ZUlIQ}l*)j+AD|L*m4XG)X(Qpt?_f+JBST{k z&?g9-K-^F_5{geC+z{iOgt-$)FueX->Z}9SU zx83e2*9_^^tBu|BHZY^3i~tn(GddLz*O)wqALrbaS?*TrsQIa?Nw>O9Zipi?!X~Vo zX!HC!E8ILdhMA^}cI{cT=UOJ?^@S0;OLtBVmvaW z!)VV;aFid&P~45SP>v0z@m3PVeC!?ojZnX(1@q+dMtH?F-ZVE1p*_plyL`*4Lp%J+ zCkCu?CKhBB?V&0*BuAP9dlmz>O_Gv*hW27Q-$t1z2=qpCSbIrRL2l4W!@{4mM(rdq zzv`1FjtXrm5RDgNu)z?i<{R07Af5V$!IL1h=S>)j=o<2lw!u~Y<6IVy4)YS0<#=0( zVv61ez2oLZg}n77H!{=d_wmtq5d`ue#pku$r-4p~bDuVqK)(IVk5n_PnqV{rj-}BH z8X>C%E0VM$Dbz~^!zly?l7+W-3xH@y;K&~=bLL=&N=W0J1S@FR(7n&Wq8%!Rep=4< zga>7k^5Y1_Vl;+o3O*Bj)`XcQL7GHF9g2`9B4^Q3<-WiauV!oBBmdAb;}-P0rK)Ar ze@m(EuPgc*bVb1|O4^5E(eo=6yZ;mbE50)KHhrkgK9giHJp}Ab4^0#Ns@E00_EIjr zId!-2a9r&RY2WwQEB12Z8P)(MU)Yz_Ztc|c34HQm{oMU3%|~RHW~izX)X{1ATz%c0 zcsDn5-a7L#t?6~Il~1^F4a){|XZ!jR4<-3g54C&A0PCme?cYtfN@d#foOAa}wd0k<4JeE~$YrNH(}PT}Nz;Qu zAK|`SN)M_an4t-Z3i5Xx$}ZoG?$FCHH{I6Q(Og$gO#G=x_nRdr#*gVw@(o7lmh(``<)d5Pj0&`~2bML!H zbdB@UA`0LqpF3T{>XQ8FcMmL$;h+VR)2O~9f+*pR&F0PQQTr6eA(vCBw9+fF;?PZ| z&*-nBvI4ez;;re;Z{`|&&ru-i^K;O$;2zw=0U`~W0$a~0u-pq$uQ2{;bqAdN6HqnvEx*YkB;(H{2uz0QY zJAzypG3FvqbmttKAN@*|YQCb{{0KFBkGfk4%rQn-{vHEkcUSC-*TqC@e)QMr@k=lVhPO+nBU>j=Tc74p|8a*7aD~>W zZ=QP}Gs#K);|hJmlq*Yc({nm&cFKpEVU1#uU=YpTMT`Q&yD%ffd~kFV=9-+ z-8db!|j2dY-Tq?zi z!-?xD9?qaI9Wpgx&7?nBB@4wLWFL4xLPN1CZ$9{j-6e`t5xN=!zjIMevW|6N-F6SG zP`HY0yY~wm6zNaWJLjrQLw~H1sP`<`eNlUdxe&KyKsup_wK`G{5tWdud|$_q)){n? zk-c3)APQ>Bfy{t9GpP{MoJ9KdAJHR3??q;@ajW zpvbLN-f>nFfqi~@`bY&FPz>}=&A^`T#_!iDA~&jK7oT1EtZzfJQ~>?O!Dz}o?frjL zjPopBHI-?7xjVC^JH?Te(H9jzT0j3^e7yxw9bMBcjJpR3E(dpa2+qOX-90$L5AH6( z6P(~~!QEYh1$PMqLV%FmAj&Ac%0liDdu5}^sl1DL#pQ;< zxo0^^Jw)V0_{97|N#%0`h9@7auOZX*Vq&`h9r?3A)b=r=Fz@r#?>jV1_hBrgV;xr= z)MK3pf%osJ^j6q>J`a=3cr*=@WP)U87jR#P2y8Gx3xxQt0A{RtcVe?<@3EayhZed~=au`&I2Jo)7y5b~D7oi6gwmNc$F8$hOm9zX!qx1Y&Bb6_k zCPRPm=2DT8Lq|CTHZ5W*ZUL??>5mE_UKp2SEpd`4(9-8vek{aY zF%syggh5JvdzjZ6z@O~ft;27M<6&@M;K+VymZ*%;#={xO+Na+I3suJg=Fi}00GK-f z>OzqSKt&p8h4DjP4iV2;v0*ZJ@r*lUfx>vbYUP2>gcvZgoP-IOU4d7(XZy2J|HQrh zQ#7-`)TPz_K7Sef}VUvB}qm)L+XRq5M#nX-hH zTF@7EHs2U=Qo!1O;f-?j!g{97%y(v1fJy7~Ll?16l$x;xj`yxySQ$4H?6)E-i z3Lan&b{+0oEJ03eK}D=0cT)@obx17Ol%(*A6&Ln^tc351YQ5c z^G90i`6S?aH47s;OSd{+7R`TjVt)+?$5=TBP|gEE%rRio1+aiW%1?YFA**?qbd>Kt z>OKkqK4t|TC)2&V8t@hc*b%cN*JH$s-xgR^@5hh~ySr%PtS;`709KFU5Z;W_AZ(G) z#yGMUz4_0EXtDTzZ-}_klK(OMm(Rb(PayD`NfTolC_8NI*W0OrLvyD-uolOll7;D5 zMw+)F7k})A7-+VyTTffJn)vJdg=NOg8-)m*aEUD&pdkP3b1V49jH~UBb{YV_yXP{( zml3U_>#t^R7b88O0gAnsy^Xc2Bl=^Pvqsp|(m9G_tK@yQ2e^W5XB)Ayz#TDnu(Y+Wk9B@+TzvW2&gnhyWnz2->{V;*_b{26j z8)}ArN|vg|S_&eYgIkb2#Zf1lUJq2O*r^CH?28Ra7>kbQv1u~aK zM+vql_y11)vj7gzo{Y+Y+#m3ue}d*2-?~!;0m{&J6zEfQ2;o%m{5*OY4yN<72l5N~ zcDC+3fWmX1CeA$G4d-7q zDeV#*2S)xWi`l4Q5ftbP++ZS^Fc@?n)%;`*TO>PGZf`mXA_*c0Zaky#Ej^J~kvfI! zY|Sm+gP1L)NkIy1viW z5UZ2R-Ua~vIFK76K#^MxFUD_48XWFykSwY{9gT&Kt~~fy6g4T}Zo#ncUE6f{<`?>f z1%pdAs9Kuf2&o_tDIuaPo-f()J%LbjK6;bd7$W(a7%|@ZQs?_|FmZutXcKlRZ4$5i zpI1TgQusze+%OKRyuApkV09G);*vkekX{+8SPWjO-iR9AegrdEhf&8t3-nj~QoJ~( z0{sXC;juThanADCSn;|UeKLkdd#>?4|A76z^Zy&{fAkEmOLpdp8I*w>4v;U;#^IDR zTg10jne7r7f$oQOs)BiriI(_b%+agV!tJnbfC&mh(c61qPJ`%=5)z+iS}D~AtA&P3 ztN;~|vpgPM5yF}oNh?sqrbXvYn7jZQCWBjL)*sP{upFhCj!Yb^CuuBc99mG`o~OQ z?ID`PJYm4dkEnYYGG1oru;T?XzeHFn#TUV}mDk-*B`ZBjcuhaL-~AK)KuF0y@O;A#$}M{#6yJUDhJf0x-S3dB zk)q#smzNVRxhhGN6S9MbEfO4HxIPj3s^RpZnInvg5sriCLFiCbOd1v;oJ=CV4Od(k}fTgQWRl1fn^$Y2B+dxq1FD@bPT8J%Qe()KGv6E z=A)_0_;%o1f+52Tye5Jf0IP)yp$^CwTcMj}zRrT?8hkVK#tdQdlc6J&^{5rK z8#Sdh7KCe8%g|ir*SPp3P=a^BX-mk^%K==LKGZ6N6ObjRmt+Nryu-5$LQ8_?^vEn$ zt$v`vrj%rcwTk*Xq&OAP4kQSXO>^fy7Nfxq8%_!8T<>iQQ%SsF;$o5dnw z$(2QPVnwwP{XRh*&9&$NV3P|J3<`at2@?o{*+uAP^(Z5 zl410qVcFmyv&|oZARd~3EwcVV)SrKC&p8`aX(N28@d6=T zacV3519n4Rq()SFDzLb3oD3~;Cwh>0e zwS|gr;1ihzpiLrWmxy6)0o7dW5-Q?+>`bnG2-h*;EgCHMzSs$2w80nP8Aff=j&lZC z@f=^ZAg_lxQNd@+bm7lL9cM?`Y@@k<#)-p^wkf`!iyiWD_5WkNn`Qp3?L{!y9-xl0%ie4{7BzhVGqIZ3jlno@s8w{NQ&^= z3r3Iwb)_iGgTH0n^AV{B)=)sB6DG{_HGiU)4t>`zw37#g9upB3>4T!Bz07_P}#@6UupfcymaeEI0363hf) zV(UFFwd)^NwhRn3SPJOt3^p`a1GL05>7$|UOvinok|E{*fF~w|2*3_u3WJ)cLjdGoZ2kz0RnKkXFL;n5Mc%+ zS$~xiMrOX8iVYsbr6~nx z+Orr9?_i2vh5bW+WgD;{sW`XSNAQ5VL0&d&kof|EZUEfq<#01nF(o$&Pd>upcD`6V zH4?EsfJhV~{E^a@1O`Y|Z5dL4L%=05uc_c7VHV^<&1EJE}RLsM?U;ZJ{ zygG++57e>?NekN_qQXS&sGIQJ{B_hv96n)dEnp$j*n`8y?Ox-W5m8{ra3{&cFc`w} z*b)I7qAog|0$-IR1SOEf2;Mv(;p|2vCV3X^LqrY4U|;y-+j9GauoviazJh^vU_dW0 zSUYN>cyZvjxGgNRP(()V9mPOwg@+J7@(TPyozF_D5(g6pa?9FAAsEJa1BWFy8!v(fDit z0XVNY6DkQkQ_U>~p@CQHi#0nrIt_XYDF+9wOwAp%FQ9NF4}r<2VGgfad&4|?LsSh& zyahQwu7xcL4vq2W*DL)6uIK&1ad>-hH5>&R^usY6>yri~^$Qw98BFegxwu%n_bgW|&c#E=fn*_0U+hg-qZ zAw>^bcEz$(1)SQWE(4+76Ai0d(pc|n*KFP949k=EixSi0;8WLoJ}N?m;0!@5SY~Ls z3>z$1PssfyTi5T!oqxRC&pd!f@4oP{otc2VXG{*}-+iok_t@aBSB>_)inYx~%~jO^ z7a3n8U0}x8oBqL8OaAGd{h#ZGl3Xna&s(kKjht_d$E=kUel$b;p3gRYUbZ^HGD8G0 zo=pK&x;mY@EB&}JQ>ZU2PI(F&Wsk5I>aB~aF|U_0K_7; z!wM0ZghY^8Vm2Utf%Pr^^k^r6*3zwsS%EkbzSr-H{2SM!mG<_NI(_1CFyy5bqZnC1 zY*PV}D-Y(Y;%G9f6%;j0j)l>X#!S1k9=O|=y$<3W2%Z7ihXQlIpby?hvmc$^Nib@C z_tANu(t^>#m)S!8`={S76#JA%$>TLNK1sr0vc}C}cERV3%`*wN9+ z+{m~Sfy(~dAhKClU$I0;6a(Ecz~fQ66(d8)BC>qU4ONULlS&*#y!h^&Y&Kw!?q@>;@(OM7hSql2cxCxcua;&rg2O*Us`~<4)bzRk3?WIyA^t#48PG;b$P~W7}ZWE)^g@?iYk< z)G}P(vmKSFKMHM8kIA)N1Y{ELk)X+M$igsvfN>7!exGw3wF5pNfK`!TVaQNY_CD(O zYs=53iT2SDA4}kzP^HbF3Abp&lKA_mN?+j*HFhr*_y_Pcy-HwhDnHYgi`2;;bH)Ro z-RG1SFC+P;y?7AAKu+U0Ih!)Sj~B_OZ3^C3?By0ek$vID&$_^d7Ks98SO&g`X!TXz z#l?%xR`iO^b^PU*^|L`z5C#lGDIo{Uuq0e@sbW z5cn<5Jt-E>8pBOXU~~zFbl-f%^oW0^EkkGon@MCZD*b~ivhW@WFobv27gtPZ(ib~pOS^*rTQdknl_Pv-m<^I0;){ zfu-KG$y8WKISOX1($+;aKgs&DkPmfM$)sW$P`Qg;JazST$Q>nP@~tF#WKSG0Ub3*% z@W~P>Fltx~Skk*nyb7$4h|KFmI=75_gQ}51q z%OXOVHoB^&K}2zeGvm(rm>v5;67#o@|GR&=tBwCPPh50zerXW4{d791@pCCa1`tu`tHqH}}2=3zpd@fN`5#=5Sg7j-kZ+ zR|cl2YRU~m;-XGeB-l<=ma$kN*k4{0gIer4SjLq6~@(!mFfxMade( z@Uv2Y#%_+Wkktc;Nbo~!%~P7anpgTTzP{A_+1&{KYQH6_V}UgFojVfHo(&qP8L^CQ z?jc}>F7 z^TF`+UPve>i`n^vwDjt7G2@B|)($!*Lys7iTjlMc;EVv#?n^rayICOb*Q^vLfCvbm zuuA=AN0J(>{tZLOjGtFLwc^RbL&WG3Ii`0V!d@Yz}pIFK z2yupUOJ_C$g|m)%0OgrdV^LxZxBg>*CJLA`zdTiw&hF$O<2y7%gY*m2SYkq!5#e|u z3MiRnAwR)2IhpL0qErxvypWjLMPHL=!f2Sre4~g2Rx^g&Hx%&2K(zsk`e5Z$11@wt zX6Q?SZs_;Ehi(6`o1YZYb$96{6zZ=(o_xU6i}|J(qrdGSYJN82n5ZoVl(oOCqc2=$ z;2N|>*bLMR8`nFW>geQi7?V;l`Tx`?d{JzTXx}n~pxUY92m^~-dPDj?J&^hVGzD)H z68@!6`Q7{G_8))LR#E=^Jn&CWCmYy~r~%r8Yng&KcmKvXPW(fmcjs|zwntvlHhF5- zZCsDv%2euK)Q!ySzwJK>Pjr}6t?d{7RgGfztu93Ud^;LKcK+r$7gDnMlKK19a@hC# zrPrW0nQ#E_uDvwVXQ6?+ux^8z%@YiOD%Dfn`4ff~ZuK)erSE1CGJ64MCOen+LCP;_ zuixZ5?py_}kT_sENC`R7@ zz8LdcANgF$bs7sH@RkYd2XqSG7rqD7{S(k|;6ua2LvVoVtViAw`uS2gbV7eLwTXR* z;Ss?d2N*f!{UZm?CzLcevq-2$(p!r`dPIr>&cM)8CD?p($$!e%UkcJQzM*jyR=<#aauzV1nnLc9-EOBaOG z*N>Meq*T2F1UX^P;iCD?OlBBNV`Eo$S@ZI5 z$i>}Ss{N(YnNTAn?zZrV#CTbZ9V@Qi0U>1WcLC@%C6Y{8KnV6a{1Dsg*L~~>!NDf% z?ACp3f(2-Ct74-)y=M`D~rxLU%W(q}d`PY^08;ld}0d-x}qE_TrnV@(?qBw20~7q((h zsYW{iM=t16n$RY}n4JxUVn{~z)>tz)-b3QDJIaVtv9twp+>nfQ+kcAsO9EK1``Et4 z)^*AJlx~7u_Ur3r7c}>zdnyblZfxgb?3(rK>q<&E29A`Z$qBk>FPBt@FNgTD-5SGv zkGV4*WF;I{H+bV-O+Zxw47+#& z=ygFKf>rpdkav9@+eYWhheoz%+}!=2KOJ->hw>HejHpb#ajjlSE9hJF+*y+igcuoI zbO+QME3FUpb)+ujdVL+TJb<`fJ9k@u9SXnF;V1TKdwNWK^TQ9ZbuF_~h~(T*WWAM* ztX9Mz;QrUr<7wkk^QrQWTFln=ww$SePTyjKsVhO<*MLH*mQl7#zCli-$=UOdp);MC z(~fL|oSyhcMD+gYttA1$x#CtXW9!@Pz7zhbn}OwMo$siFsMivmSZt8NN@iQhPAcr$ z@^VKOV&ZGo2%W0z@ozD()@Zd+5ju3;JDxDUwmLA*5nsdKArryJhYTa}=*~vH+cDy? zG(Ttc%J|LtZ1mUxlV;k)M0>I3{Cn{%`>^8do1n-{YiL(|->|at)3GAkUAM>7m5-vQWO2jsY-_`-wq`Y*Kh=8zZ{=CK;|$rpwI5&8 zh(^vd8xMYQKQ?^QfEs3FDs<0F+RLcV(W!6$@g?^}K@zIZF5^UjmuO2%dpj7ovlioR zqX@RWXqJJDc?GWwCkx;{b-XFfe$0=@lJKRjhkF$m*%GV)2Z)ij@hUfdwAUBzQY{nb zj5sytjIA1TX862ETDArBVa_>4WBa9h^%U*rB$`z!bPrZslR7X+B+p`+<7hY2eXnfW z`Oo=5q#5Mtlw!N2*81xA8_{tg-|uc0wbj=q-zIj*r+U6+7fhgjRrzdvTFE9<+xhi1 znr}y0q(|jm_b*7Kk^3$|ph9(IV9`+%9r^uQPI}{;gL#1-yY7d}1N+vepI_|55j&s1 zUXMIZJ;gs8#h6iQ@S>!jA`^7ODDd-sL`$D9 zv3bJ}P+@g*yl|E~3$cvnkgaqF5yS%Fjny6z4UDkUwRDXNS_?1C zA$`@`+M37O+j!p6>+eWwqr7_0QJN&2!?kj3;XA1Ahb1V%V%lanVFr}&44)R=m}12F z8Ibgonbs_{*_kr&CQ+=Vv8(#mP_V(Y+I>}~e}AaYG#j(q+>|gy-_%bL6`>SLL4}2$ zGZ~|=8%`kZjW;X?(`9N;@O~I&uLMGcRn;$KQH9c2;tC$xyZqzVJZ}W~;dVFny_M}N zfZ0xdweYE5cHo{e9d5m=dx#eb-TKjg=~9XG25QivBLp}O!TMOgC;rKpGC-L(YJxn zFBv3Qt7=I-I+C;@40;MeHSJXTj%NQ)CG4}7+Vpq2y$_wAS|v zwALd$ZGKM(NzbKQhEd}?L=eMJhdJFWHvY+mZ_?@0@%vWo-gFVhp7$#i{5qRpvFYNjGRi5x zne!G3M{F)jFsvNoiViBh?J%Eqrux5@{=Z|)>M_px(62(+qYY!7+w|8S&mG$9g@*221Jgcam5@t zCcmCc-CNsryAoypoIU*3ceZ%CGreEX3n%n{{nm*DFJ0{_@i!l|!9DHhVOCF0d}=T6 z>iZau-j?jTcxr0o^~`>_98*Xm?P{8!wZs&4IY=65O&!mSctkuWE{Q@Ie){PhS}vzV z2)mHIzSW3~)1P6SFgP>Cto}1Nr!P-LG+|2;Iblf@VcFR-$P&%zPbnu;fy2Qu? zSuVb=q~JEM`AN=ZJ_|_QAK+%?$5S{$xqCD%JROB+Wq)_y@~|;eNotV9im1M7*~l_S zb~c+0{c$%)y_m$Jo)-jhbUG6!<;hA?5~U}H%f1mmGw}HoY-{W|i;Ee9I24L~8aA{) z-^Z@324e|A9Q)@n^ggkt5;dhr@n^bY^mA!7^ewY7b9~aebu4uHzR;)JPrT13q)TP3 z-56aMClCmVF7MSn)OGHg3n40NkW`HFY2P-~4@xfBrxsI$=#?_RdOg88wt{m|$&sq4 ztJtMpD`*XJ@d|WS?;$X?hEd$TL)g7L`NSuB+FT?pqXFR-MSEJ;QQB89nK~sQC*Nse z($CnfvPHj4pL*-scY^utbdHnCpyJ?7?()sSk0F)su@G{{OJ0J?`|D$f$XAmyC&wPL z^FYBTW;9VWNGoqb&7V*AvL?-1P7c*AQSN4g0-E(sb^7&FV5ct8pf4?$mNC`lPn`kt zC96~|Cm-k39Bhmobc}@|-*4~MCPvOIWR@@fh`{#zK&UZq2=ViZxtb;g&9smZ6vPM# z9hJ#q+<(QCUCBNDQdW}fQsBAon>PI?!Z4|FBLu3Q3c@D$kt(BPVk(QxuJ zxmB_eDaJbKpNH$qQo?xK?(V^r-)Du;iCAyl2aAN{w50icNE?hoTjyl$+_&_ya zWzm6(Z{a^WfbG?Zj(yB45#}`W@_)!{jQ^ihmGyT~K zGY5i6iUn(q9VgHAgF#Gjpfo~>mOj}gxSS$!c%jBFF_MBU=6T@LVw`$dk@D`;RhO~A z2NIP88x_S}HScA6lntI!o5dMw$?LWHY&_XsjyV-ZLH=>lg9JC(cF+b3+&gqy>mZ}- zCK+pIb`CgDnOv&9`f4ULvD|zuc>a3iz!HKtp*)BD}H zSh#ls%<#4yS>OsiB>CT~(Zv)(jV9Ax`aT_e(3~e&fN%1|hEvssO~dwwBk$9Z6lpzM zXI!Y`wtA#FFoH6%<;fh*@Uye;+0V~N8$T=mXFfk^;u^X=UAalm5G7%sC`iUCoK4T zTdjTUs|^s&(_P2;FN|T6zCk~_z`v7tcEOjL9h`sVww=j zR=vqm#2YxBS*aJQL9vUBsMKR3m`%EP1hL+uXik06BU$BL6bHf1Us~1{ex*Q+xAE2l-Pay(hxTkX?`+s~J_}>vyt_^v%W{-ld{R_ z%%^)yp%CWtv*1q1q*8Jm=ri243L_fg`v>${%_~>0y2!QR)ErROk8nBeNADtx$}oja z{%KB$g!G3w4E?NMP8i@(Pr|*`l$FtVj|-Qj78O;MjMJ2>wT!e(- z^S^-`tQ@6*-uLqs=!`GhDK0dI$U6P$E-a|gELKVggC0zq@~!jLUJVixNUmOvP1FWG ztOg^R-z_~S*XGhH&`n#3wFDrA3#@xtjs>K=jlwOgcd1$f6EOkKedA{Y}_5fi| z89(0`vkqPm+~`7X^0~)sgKmAKhjpn$+lZ1Vbou>+3LNTaH`0V@L#If_KuSpKoLXjV zUcD_i!^RdC#ByMqlrX%kK(AXDb%nO3db3pO&W+6auOtt>9i->VtJ+JYWUmsx{0;f! zBvQUv`z#-pg>HpKY*gP97kz>7>>mazQJQfs{xYGYl>P)wtBZH&719EeDd}hnLPC}Z zNuuCpvjiF8X>iu>WX>0JGfY8Q_2aJ;ckEeae_>AzqcM|P-KZiZp$oUrv*YA0HD%C6 z!MCI>p`vIUysTbLlIz8(vqD)_&JC!kM@_mwaN;|-325x2Es?Y9=Us)oSF`TtP5H)U z4&aOae>&MUVgskYGv8l%o#fGpf+bR1lr6HOO*MXivGotLi}+oHitx=k48;wQ@dF$i zHDth85=w*xT_TQ}pBSiacR}Krjn6~!g2-l33JO^ANb7pxV=_xXISG6ieCb-fIM6NP zy&6l=g$}Z>>KUqKDki!8YZ}BUthHc`d$FE5DM1YoBjVC(fMK5A)T>VvTt^w-IANI} zM%|*Mcf)jDUQKhhro$hHa&ETLV$&FnoZ$Z6%Da}N=+3A~p^OWpcx)pe5?CqAeYWoR! zRVOurMc%Sx_E+{#JZEe(D<-0WT&0$qzrS+1I6C)srPQzQf&AZHqWQEOWFl!9u4dJ0 z^t_RFbpIv3<2N&LADEUg!v)JjlR<{?A--Es2>hT$E$QMGUTvu-lCHJ4Kdh3Buws*E zO1iRsd6B`u4f_GQJ7bg^mImf3J>!ZSHU?rmBJeU@8Od4d+J{bOGZMdAZm%QvYNOJn z+h&tcmD0CBdu8dB8VOR3<5)#A>)kBu&VDm>Kr3>oDiJMLIZb^m7KNq~djAus-&ONZ z@Yx&dpJ+DTqe6FV$Zh}~|58)#5c1%B7Ipm9-G1<~z)9}aleMsXTZxmykZc}UA5zb? z$CshZ^!A?i_yC&tCtexnD!+vccHkyP&wfntreTB#SZFp=o?QW&p+k?cW4N{Oe2o=$ zo5{GK8J^f*+7h-tUami(E;LTd#tT12e*%HfAn_cj18OL}4%S4AnUftEyt-+_2AUbCFpPdsNymfYt@>cP0X{~X2R$ic zYgmlWDuO0+fdC^fV@iRgEeB`QE1M(R^K6T{o(o^FAA^#o7bR0*a)!;MV8GcuQQ>lQlPf+ZQ9rJ zWNAabf>-^Slo~j`G=*^4N=;_+XTr~{)l97ssh;Q4LGQR*Hp`JyD;DfwI@O7~8a{7q z(^RG|jh$M0F0J2MO*RmJ!C@kGDVMfS)@R;0t)lIWh!F_Ph~$H1QYkCi`Wd(4t7J!_ zc##|M`bTT6#07vc4Xo@H<#>IcRL@N>>{F_7?$cIVqX_IW7OY;GxQGS3 ztG&5DzTG{`>#KnxtIr-@8PNQ&ye#8w6dq5Incg>D!Rr~-pG5V1-d+C6{FF@HGa-1D zHQv_@pZ}1gX>rr4{E+cI!;&AChcTm!tssymCi`4U=i$?NeS)Bnl#eEL<4k->DdX)E znN;@O2P-O1Lz|A)i~)XFKj_wsHv+H}5OP%y15IGFmxftN&yB^)&_7O!ilEzWp_OaY zLyyaRF)h&t7q3{amNeOEV`F0(boVQ`i%qSmV}pYOXFl|nq7B6^W^EO@28pkKYIr&% zSFIl%2cK$V-`gYSp^uXj+g3}N3w0Brdf(}W*Lfehe*;y%>I}D4x+8y=*CNmovc56= zD?gpoDq=phFr8Py#`@+8}h)I)q;+!#a$OjN@;6*;IvP ztPa((#Oh43s5yJ6IY-D7Q;ldGAYG-b7>d*?!F5N8u50ORsR3032wlRTEn`GwY%phd z_(=e80a=L4pZ>mS-k10H`wA>;X}k#Dp57`Hx-B|$d}P`F&2l*uj6O3{i?1#S+>^K(f~#x^(t>ixDYkl0#nSq)T?pq~+^z;+{LO}7;|T{fvmHmfe$W~J>5i)$>CN>IurDzI>dF$yWo9)O1egWsm)?9;aEIkoB#QcTRV zytXKx8n=(Zm~WBe`-+G4VL8L(W7T4V0~;?EPL2sqj*4v8^+U~F_k5~g7GmIwdG?ri#s*n!d=L<>5IM+r_7%+L($$>A)MCGWkPQY3xn67+cu(7~46`MNSDt z+*evsCqB}+*wRv!w1qP|#yv#t6>tAs5w;cbeYL7R6g4!~RSJmgBe zFGG?^5T$iI^7%5Ic=Kf%s2E8%)P&ZmTe5eDW}FTb;Fne{!O?UKWXFSjJSm@F_uj^( zgI7-0(0U5o$IY}?QtlEC2)(VuUfTEj48V;#n}!?ZrGi2-0$S8hGkGOd6(mVN8Rog~ z9aAgz^w%L>0S3|~3mdAHPSQ}#KZBvQ92^%peU*lx2Z07UVsWk&aU+x7x?bdnc(Oy# z)wk2IvsAlL{CXrhT#$nw4VAPb-a2Vfpk0`BEj7b4JZRgKNzCa=^U(Ly$~cIa(QRHi zK^8MmsJj)xlH$2u@{&;8B$Ewr#kiAHJ79jCgfK|uJKEAX9SxT7Vssumd`<0rzvyiB zAWHT)bzPj-B~o;A$TkY594;-^b9NxTId-PRs<^I&+`5-3jH! zvyO{4CLu$%bXamNi5E`)B3&ovO)x&T?4VCCWsZ*gVBdg*RIYzwMB~rK++sNEW>U9V z7YMro23@3(ad^O2V*l-L>RfXGZme$3C2>(~bp=>_q}(J~f9VX0s1xg@-yqBBrl_EmBsQG6E2bU^jz z&lQ1WV7`IH$6Aao#suI^KQH2G8MLn62sp1W)hYVm7Yy=y;t}whM3Wh30tS9joVR4o3c0`_RXX@;5hmWzo`@Qv_8`(Kw;Xn@#oXzK_W_{Px;wE+Ab#Nwc;dePZ-3mG^VR z)z6MHwpPiq0=CjE$xcD+f@9x~y{A-q^bWz8_Pxc3T}!-QTT<EOMgNC2_G}^X;PT+6%syLh}2<*)Zx!P*M>^V>XpTz;OKn@ ztRKHPlsj&$ZaVLGgv&T23=&F@*RRfZ+7TiLB9pnzY$C1*^0e13m9P|&U>i-fX%wNX zX&}SQfGKxqq^5;|cI-nWBdq&ub=@jt0S~wvTe+D>!L$Y+kFEzt0xjEn;IUODWnm-J zkzYTT6jbT>KIUlER~kwWr)@Tuk=GL21&)N9IoLsL04vhh1S$jnKdx{5t_gl{JXZIw z<4bm4&Ke@)=F|Vj^@0E6`&ccGQ0SQnQIM5GQnwXD5LAIkiU^MRwdKjwcxH#FI#_qB zIy?-yaCh~uAK4Lad1W(VbFOc(+I?Y7e&~?lECh=Wx%@gb%$>-MSVg12Z+A6jujmKb?840#3LC470@Df`EHbcA=FbW%XyOS z{n8?ug(D%H%z=xN?gqTJfqaR0H}cnz&6!nQaF?3%B5|+$5R78*5j^v5yfj)%vRRR9+^^&yE}T#J%V=`^4;RKfM}FsMq4NsKpZqiHpDt@FC` zao%XM@|`nh-CLSB&4eKy8aZ+SI%2x)SmV4saE*Wu+`54NF;LeNpk-tHXiw|vfi08~fxmzo~?5p4tByA@01^1qHgKA&PTf2gjs9Ej60&s6gy0P1J!#}_` zG^;UXEtU(mp>(uvNbEKv)t>K(+^SxAO=D4-r?eXy3pl^)louTm)0E`+1Hig>cxW+( zaS%;R(c*$RV7J1I*RP2R5Gf}vd-k;EeGcyS7JO8h#k)!XlzY2_XuY~=MB#(%VF@wP z&3u*ixca5NV-Pb0a-I!<-TA8|A1|Ur+^i__C2&FCM};{PCu6T`w8(N2?`1HmIEiB>Oc(m}cO73((+qPLVO z)k73hPsDR`p~nvvSbqyUM5P%DM=t|F-cX!(VIS_C56NJ^F0K9qAE^0s%2Q~E2$*@3 zM`8PHQSXN=w?+)fWeh&P8fS3KPa)1U_3_2GTe!gGi3X!*mt>bqq!tkK#?3INR@9S(>H&tMpCo)vBOveU=H={G+L!1 zcT)@TENMqaYB@TEd5(;weiHEtUSdC`((dOISD}lho!I-oB&HB6d**8)z|1S!;ORWca{yk2xXOQK57t|dEGysl6_Q{f% z@_}36HIr788sY)6~j*h zk05||)A(8BbG>%YMdFR#onzQSI(opvS#Z?lU`8AO>z2a70d6X?sBZ?9>u&X^llAiV zW_4`GnAf+lUvGi@+D~B~m}I|wV{{4zuHqleA}lQnan6Kw`)fWZqc97ht1TstiL0T> z%{G2{{H)TzBDGct3zGIL6qz%Q%SIiA(lZUjA|8zrF;84os8uj6HifWVYQ>``H<4A# zp7qr??TdxV>3fOH=+*4VmoH1TUX zIf>~xDM=b$?2Q;yDi17amjXx(YwO!68<4;I^R+S^wOg$9&%3Kg#MV|LXH#t2 zqIy}IhfAs~5fLR(M*(edJRQDil+OwubL>Mxmv z=uHjQvz6X~86CMkE8~Prg&?D>0`c@`Rr-GOYUP+DDmbU_{`K9|{ZMO+A-n*vNR3ok zarNQ1RZ&DweZ3l&!4;}F7%Qa32c>^i5@LqaZ(k4(oC9Ex-%6{^R8wQ+G3P_|Wt!t6 zQdz5%A51-}l`y7fWSzRLBG@JDt){6o(Qo!m=jjmRor@(b1XHJrxx}s4v}uy`)>N1U zEyuYIvf!$O7b;?@=2iu-6ipR-=4)>qkd~)!x-v9+BqkN35MCpb!RUHcDmSQ1n8hGDV#*tRdofMu*$&58J^ z_A+bn>ZlAxO6b0+(%I@cHx_0#G9_ZQvz3Pguir6ucT(v7wx+|3^9_4LDclK#fbBs$ zc5D@Xg^MabJ;}cNvMJe_Z!!dZ+MdyKT4?6tEqVj4e5LKQqf5_&JEG7BDGbj4#n)TL z#nEir!@yv{-3e|PJh%r)aCZpq4#9PBcMlre-QC@TdvJI6|KvI6-gD3U;r%e(Ju|=V zuBxuCz4uzHb`9D(0TU00hp=p`zm>Ii8kC@`rHa zyxV2tSxchC{&Sg99Y_=EE=nC+Qk_8(;_{}?-?qbpc}`0*hjo_q{T(q=CjUxEd>2Ir21N)$g*%2F*r_cM1!CahR9wtM2 zPI~AkWndmsw-yibwl(SnjyDbmM;m%j0GYme#TH}GBPqfK!5yt)pJs>e~b5m znk7P!7^7=tY2Vy&_UqMkkMv4{1O3&sGy*pTs1|Doe@h-F2pf_{TO9W&*wndzckUQq6xrAU zg5(-LaS9UOe9}u$-KzI$s*a6c&*SXY8WKiY@6z%-LnB;=7wL&%rbPN6g30I;&v=6c zzY>2se8<))funhBSRUObuj5*a=3L>X|Anl~EjIN<**?2T{ySa`nwAO5T3+C9;T4^2 zr%iJToLMPX0Do&LHr=cQ-y)FjTau9@#b34v1%^)l%L!PGiripcRQihY8$?IvE z6wDB-IDQ@yhJ{JyaByn=YhO+-HNMn9T(wcz+;Kis&DYAG7b#)+2E~i}Uz&K&Ig7(! zQhy4?hqU{K{2hy;8e-RftaSe)59?b2V*{reJp6s;YAs+G`;cIjGi~iRZzYIhpmZNB zA-LYX`zrtcDP%%8d1T+l zmnSDMzub7fu?VuAc=nrxGX8ccq(O@_APa2_JNH4rZ?cQ0d$18{fbXE)?J?=*<8h6h zaZgJ^S73W_b?lf9>tB|+4QrN2DB@h}R+l~1lzBOBL=~uPz#{l*q zU&dT%Ie{ZzW|P8PGL>VX_fM~#<@Qi2-tF4~NG3JvaA(OI%qMT_BNarkQ5GgoI4pY= z>PkcrjGEglncJC;!KOD5M&zXj(hld#Qc^9wY;C}$wT=fKdGS5zPTnuL6RuRkwPu-s ze2mx9eDFJuN*!YVAf;1LeE3ra%M~wy;q9?DoTRk-%p}P#1k`aIpiGe<0m4#ZyzRaq1LK?(#EOaWMZc z#X*H>lxh$jH6+9+nsEqgUxQ`9?Pf!+@Ng5YL_u7!k%d7VicdTgb6Scd`ycg+{+tD%V|TyOisbTPGv8S!M&%+lHgQf7V; z@&*0Xo?p@hD1r|NH!)QEawWYCF>b&NeH6h1Fm2{1wELEh?PecZdl#L&;CjDxl8@_c zie$boryPVc?2w**uUylRDT`>=QBJYqFYa*Z5}%VXzj=1bD{@2>0cR6C!fXeyu}%(# z{$uhhgEk_H=9h>+x$uLp>6uCP^vL1c~pLJcX^l|-k<-=gmzhZRNvEFZhi zXQPu@R85+yD^E9#^rTWlqg2mb+o)6F9aN7lEmJ2Usn*n2;`aRk;l3T`B z03%?jF-p^ghMe9vAq2kt3_VWqng^irVXEL6M5Smi4q=`8jXhF$+&wd!6u!9#W_4-t zSFy43XwiD|T`4q}K291KFrXmh7XRz){fTU`ySF?<02=<^_Y--K&RoFktc5h&=-IN3c3cupNCqlJ z@%ThW8-`Z}hKntfttJ};kxywX2Sn2dL=+b#%E|#dIZ9}6OI3VjDiV(aWo#Xp=csCE z`^|K)?H-3jufu`cd&RVpjW|I;@C0a>+~j)Zi>-}=a<$l1bICBxH*t|_vSZASZq8zT zrw3|wO62^Y#M_{lAn7@%1Q)9vECSWGYbhn^GDXPso4y1S`oSPhu!9tk{xu$J<{hWQ zo9>TSOKbHE|KifI^@@%f0;N(qRv`;g)6bM>=*3jSo2-P_f))1tP4v@Bg(GQvOfC#Z zb)#gQIOOltpOfh{B$MJ`(h}$wk-m}{_7+I1QfpPjoc1lf6ST7Q!3H$6{&ekH`W3&G z$F)i5IZBY;!}Y&@8G#V8(@=qFu z_!*UNc({l+oAH{aJSaSFR3tIrtvvuH{oTc$P3LVE`fv0XH#%Bo_J6CzGhT7?_nNyr z(D!Sc|Klxrt5tFZ(H{t=ubXk&$ni;wa=$*vr9u z@~%3726(k<*rXd-Lrn<9F2L-mW11l->848QFx8&l@JXf)tfBlPa4dRUx8-cRk<6(9 z;DNGbPj=7%2tnE=*J*%rj|k=+RMF}tFpc2GlL7i|zhpk(Fm`@|n=&hq3% zm=3V}3MPM9lO|T#25&qX}>e58afE|6M^ehM5~p+P-AKw4$%mYZ_!m{*Oo5~q`YPw zg%?dnkSP)NHQ4+G5)Y8Y$li_~UcyPN*HI#aQvwlK$cZq0+^YkcCv8cCpj|qpZyVR> zD4QctqwjfR*$hnwo@XcKR>26eG&FRtp1R5yL=e>=Ge&eD#pM<555(qj;z(Bs!`$un z35`wmH|)R#Z?|1V*kTmYGV4H^ULa8qJRcM)k1EpzkNt1Z{^HExi5ygP*Gy0jGF569 zK%X>1OyZBs%65)K{OeE7ZvUuNImk?i$s`oWkI;q+Bj-Qrehr-u@jhm}pi~1*FV@U- z4~t4KYe!C_2n1)iv*uQ{r&6|qv4{yiDEeU?QH#PArQtZq*khrz+?XY%XMPNf$Y0kU zN--j*=3tEj!@IJyh5 zwv!s2X9NZjPV6bFBlp~3RukAjrYXdll7Is=dCX)B6k^wUeR1NKA`Xmf7&p z|7K^+xvUVsyN7QBH(wA|< z*bZLYS~JtlrBp%+PP^nXQ-!(UH<@8UHO!ED7b+bOYh3OQEw^NpCY%n^L5&aM;CG7z zg8XmA3Km$*7`c51$b`CCQSR+&w{5Z?KRhy@*y?J(*dLZI-Nj^nT(1L)gWUyEWE)p6 zDHPBrO`y;ieMZ<%u=rEjbYL60q@*OZyyQm+)|~C9lJP(VBeX%&U> zymxFBQ5BhS1*NRA2q|GO-6Z`oOXvz(LO703bitL4DJGD3YpuA>Y$f`x1(g~t!CnA5 zo&|AdNgx+=DeD_UNY}T1{58WN-T!eqP!ZIptjW@!4W-E9la=JBNZz^q&A(%cDfU*| zA_ZFtxr<&_kE@-4u=WInVzW#CgAsrTERkL#bem=l+!gNzv-`lxV~84fE+|=8(BR~l zPGdV`X*J6-4Amd_CZVq?&#(bp50JW(x1-@_dt)!RL9DLM{+QwpD9yCLLC;A zEJFQnHeVlEQLFe14w!>+%gbg4Gx`2Of$&`aVe&0_*MDu0CcVhK6|7<6O=Pcqb}p|5 z%Dmt-X^6k^$-GF@=iD3Gm8m`Lx%G#eZJI~*1< z@~~`8{0Sv*=@}#tV7Al>vrRvzp{+8lvFtp(*A3O{fW5as1FS#U4Mz?V-A@+XpHZlE zsnwYqwz~KStTX_Fm6#QoA6M&ug5cNS1&JZRgxgWD>6w-Ig+tOqL7T(rVm;TSJ0s5L$PbDy( zGkejphg&!I=%1kVwFYWU6QOhjGAxT+#%q$JnWwyAZKY9DndcU{dD*3!6xWtnZ;F7h zIl?U7L8uz*Hzbx}ddYg!ScyXO|Gb{1DT{CWK%GHvIfZ0Mtw!a+=T&mK9 zG$Q9^dWs~9-L^;4q!~G=#t|C8vV@{m4ES%cf6DHlL`#!U`UBLY=5NeA-R+w&92nmp zkgn1EI6#PYdG&aP0>`T&Agw1Qm09cv6dn!Iv`)jyX^?Tn%NpqJMH0+8aHSPVAY(O@ zkV6#im6G$v{Yt^GE8(V?nP7^b0YKR{MXTP7xp=9$Ao@H|+n;3Fz88g5Kpo^%n28(x zW0^QRUhbjlu@E%LaF2wHcsG)A6ao@kfgRYDrOa6Tc~~mBe+1SNEbfL99Q@T1hM7>K zyRX5v5AoDQl~Ej9G*XmlKSz~F#lI;y@eNZN&sSLf!9EWgXrK(`$%!f&We|)w)#}0l z|1$73XQBr`lDZ4HzYG7HMr;O#wiZcZ5jzUL zZ-6l_Dv#n&yoE`!#iF4nnWe|(r`eLL6i`)N6DbvrcAdit(C_eduSkJk#GXvJ^IO#( zpP2o7#U3ravu`66HZhYXC3g0eB*Cnnz6M(?Y+$H442pEb1{(HCa-x6Sul_D;nhBff zMfO2F5NM^m{A#4eUO|Vh5?ZGV7%C5~Bf2)m=g@3mOh^#gVu!tI!||EqQXE#sw3_zB zK)k2IE>-qia(a=fFn%W1k$vAWzE_UWj4OjOqmeuU`-sI?n;YI2Cw|tMQbO!^tRp3{ z#NYweZ}YY?SGYvjc)KlsLb_Z;n&=Na$KUI;L8o5s)Fl z;JKcVx<{1otB664v_b*Ajd2*I89K(SJS>bwHZ6=rFFwpjB1|aj)L5x$=3isnZobjYw^e*sX6Jg)Gr(>hK1bE#feH5y4(yRCx}3m8MpYEvr^rGmy(rt59*0S+{YEnYiEX4zVY%^|{3TyMau~I&jBl#2$9k1*` zC{=TAexWn?RGwmR4=Bd#l9T#UtPXNxV}Qv=*e(GZWb6m`I7Js2#lM1o8dMZd_SDq$ ztoet8lh8~aP{dWSxY_Q6q6#+DyuY}|pvnK5=c83_*xDQ*eF{viUQ)XrB@q{Ww3SaU zST*9|?-!mDu3(2nG*r^%1fd}<7M@{j_cC_kw4&reKnPZipo54Yaf^z={%BUhlS(mp zo5^Am*0hb~hGGz4*qw5`;joF3`HUh4ePxuy?wYox7Yl)@9%=-0ZMK%6g#jd@&q{9% zx}#Xq_)I05Z{oPW1N*VCn{{$jvE<)4ZI9OB1R)n(`hhaBW zg$7Bpkh?L4n-mu#RMxPK{Df>Uys=}uhv>Um&mh{`+bx?IE?sty)%jOJ$$6|l)Y$t! zMtOT{`5&YFUp5(ZYtmep&2virG9XG_VS~OkZZkP8q}K2)!EdC&%fxMOwET{KiHu#* zG;ab8k}_gV4C%w@JLFd}VU6rEc~x3qod9p$DjS44^MGR7EOotvH4c*rg#Jwm*S`gJ zhMBGn(_sC`D%#;5+u>fnf4Va}SoJCqIpw4GyW`cwhD5^1PTUhug3#IIVezb4bEW-* zggcf+nbQvU^5$9H{U=&ZdB2Eeqp(^xDAX=1E&}*NAXvoo?TCDmy zg#IJoyAJL|kKDXT9U=iC`iJItrSfMg=QoPQk^1CLT>ycA*x;9P&uFeMV~G@ajUi$fLjlx-uwaL4TW_3XsvS#LKl>gxNgT<|Gq#LaWimAt+?9BJ&@&Wmr~- z@ZBwaIXp8ZvU=*wco-SF7#V-H9^*QhDJQZ2(juSy6+6z&fTdr%`(Q0{ zRyOgVZLjj4-UZKVuX%=!jc%Qz$wN%EWJ#P!NgjNqFlc$ioi?zpT==h(qPbxvNBgZL z#$@Uafljz2DoIytA*=nn*VW7EsJ+6$-Fs%Jk~_eZNlSyDd%y*EBG#Tj;;glN3llzCy#v;i}w%?`>YCE7!Aw?Z!_BCK>u*?#vNHgXZ49o(bJ1Uim2xR~ON_{|_Jm z_hO3>bcO5-rYX`>sM_Ew$yqCt33FfX30pbC+o@aER0J42zIbH_N-wEV-cOC^cOP+} zfx_4%1)gt?>u$g?dZ)r67dLHqHn9*sFH6l-B(gDV_Xh!54FXKxI2PGNTMZcTq>WO! z^J$NmGJ+XmFtNUq=^0IDLATgQ_~ZaHycnr*qDc?D5gq2g%yeZEpT520p+uBMGobkC zDAz)>HhR7eDUoEhT1r6pR~8Vx3^1B|N}5mIfnWvm=M;A#?dM3xSl1z$fhiJQ$zgfq z#Y0HWX6)N#XsmO|X_kQC4~=q@V~=D-ds@jrD}XTQwJZlfX)pN?bAG}A>%qV~4%uF3 zo(Qd*C5xmZn?^lXaKQp65LXbNfB10yV}7A|-coW`??~DZj7C-3T!5$T%`^=lQ|g{QD;d%nKnMv;CbkC1AWFS96?V+2sCqw@Cp%dK^dTpc z7pwucke10}HUM_W-DEEt014pz?KwHi20%dbI^0MQqxI^_%nr4Y#SJC+7c=tUvkh(k zXENIvcrx2wZGc>K@*f)jHtG>GV|-B%0Q?4 z>jL`sc6?+(@0NB{k8=Ho<7JEc)9_oPz`Gry4Q;+57aAHj{#^d2;I$q;zDKRf%&TFS zPmV_K%T{ldsP8;YbHg9sk?t!qPnafk`Q7fH#@!oJbFF{Qy;Z#&%(A;yCG;k$I47?0 zjM~u1F73`GDLH{+*ARwmXpoj7wF&IBzpKp|vlO*tmok=&>VWyq3wEBC}+Cu~Q;wfKo7uM9ARMxH&P|awNwy|sA z95IhRrbK8gIJbx+PC?!Y(KY3}`S7AWR}e5xNvnUkhHw$m^g-DftGz+d1MEiNs9U;P zvV!ayJ&deBqG3Z{!diWt;*qcAzUYmPZLnD%-h*_6Ag1L=nv)1Yf$q#1gS7JDmRHz@ zaDX6$ceP|kf#y;%gjs~(@Iekia0M*-5Q{paz$4rsSHa$(jeNl11}wv>gFiWS$Oq)o z_*f~lQ|vy-2^a)N1XCg*Na~zENYJHqAWe97WTQ=}Ojb7eF8syFN?0xcixdN^50ViX zV4aTnJJ)@J-l-k);^OLQ`}&KV17VtA&f~^w_r&mBdcDpyKEAYm2x{^u&Gm8ygU#;xjj0<>RTnRh z@qzEf=L2uIo796mZUOtf7cGXwAg4`|dMw|D`lZ~7pB!3}Ipb)I0i`!BK6Yf^sn%5k zN>zI5X9YIn(h_?c@xCK5!s2%H{~4KRG6WgGXbVD2-HvVYfPf zOp<=&vylx;V~W-o!yb+Uu)Nv$IBBAs6gR0k-(fT@bUV7I(z0|7)W|eH3Q}HEe2keD z%H?ZNfsd?*@oU6hVw|O^l>4~yn(gYbksxT`y-ghFn3=voUAGqQa?% z-g*<=y#32Wd}$qf*UAx9$f0Gy@(IQG zsdcyrF5Ws$L!h<3)}kscL~lbCgH`DxsTKS1Vt3CqXkQNJt&ju5l2#$cjCNW+C%dm< zSd~UP*^_0_skWiKGJ=Gtu}9aTDs{&NCiJO+90$@%>#5&{S9%&!wDM)$4_CrsDN`l-8lr4wN9-=LIq`HOCzA~_-4 z=cGXfLJ-^F7OrCO(rV1SNgsuUpI7buF%bOY{N7`2dj9-A)&KQ%J^bxgW7W+?uvo@9 zj%rYAu!nyj-1^z2b9AFeOnG|Zd`mg=MA9p28N-*HSW$}5Zy5dx0Bdl4$=GmKSmW>> z3yzk5*Hekj)(2WuH-z0IF|7Qq!)|UzTLK9;#4vy#DtK2;F>-fu(Q-!K+HhmFsksvV z{^I>^XKQPCbErFRYIM8Zy?@sxj(oM|-#fmy(J*hReyw-Z{}uVMLlfHj-+o=Bva%1^xO*+Zg0O;T%F-Z-0)wM zcGY}Zdn@|})xB2@6hrFD5ex%3wX-V@f>za}s?9-_@Pi}RBK`6#AMyiOZ&J1uQwDv) z$dE83mCGQKgXjjZ48snwK{G&{TzEqR4%vhryt*)!{*gqBD~U&=nCB8}L1`7Cey9`! zT{n-_=bR!uCF#NxSr$M7VT$@2Z6sY#sPX51YKQNmpV-1K`)*FOjP(=0lG^q5F|$aI zEi?DV_ek`{JBKaN;UtDQ^*Ej+8?2fw+OA;KDvn(kwIO87NoT3YfL6iVloFq?Yy)&j zs82Xs->tEF`>e2P%{Fqpq$B9&4SKzKs0-xAgsbfqQfLM+5fz=?4D?H&DqQl1NV;ThWx zu`=IoY$IfA`alSm1ni;qedJJS)GVkz6b2g?!Z|2rqS721HV5G$EPayJ+EZnf8l40p z(kqb}6{j;Wt$oYX2F{`87$W@*-kl4c(%zl-If4fa^!zWIh0hxdWk@cl_ppelNw_Bq zjk+Y*mfBewmC<2=@}@=VAr5m?16VT^mD*Y0_6xMJ1sR3GaBCdqaa0>12DmEn;qP>W z(d1&mWa3fZX$Qplgns2xO~NA|z%UH0?nA3aU|^AntQjW7oo8hEKlPLPr+y~MDOSH3 zSz7xdWJjnq3|ua^j7~N|G6pQJi?5-%CTnkJS>ctc3%F`Qx$9f|90~pVws0U2O3*v; z_iL-8OBb9sh0)gH)IPRQnC8mVz8owV8G{-L(G#f8ixwgM;KAZwV}1CZZS@jdp$eeAaYDooc>;%p?&{j9w@3Pl$aVmx04Zg)WkHS08ir;!hOn z0Sqa52Xq!uBy^EJG!{^j`pV_G5>>uwRJaJC{KOe~ZQwvGQ=a zd_BKEBVKZn3(}Ige0qC6$9-!CH8nP}Jl#~@ZuXei>U%UfE#Bl4-85V>^C6-3_9FPQ zTlPW6Q$0o?u?$m^7ij3#cHmTB@d}|;Gk53dcm=69J^d1q1_i6fc%zL1!Idq4a#eSO zUXY4^VV3HX6-3$puq*l34^MbS6`y_t`J)xQd^vzGS3(4Rl4)^Fi?R3jPTT#RdEO9#0Do-SI@mIaJ|z5 zvghMw50^@y>q@O-c9M+lS*f2#R0f0l4`(~1a_{Mvg6}sc(Qn#~@Kk%v?K$bNv6bbO z>Ik*sW$B;WHIh?ScoKos$>}WU9_^1=D-lxOcpqP-8NFTxb?ezd@2NG;kgIPl-+~t8 zOoJ8_kAuMJ^`sGJdg_=Nq)X*d!p-Zu>ynmDHLHn1ee=9+!srZ1I8x#HPWe+cb?Ta- zA@e)4f0j0#@_wD|hjM9#;N(#8CJ>LHAYN-51&64T=k!k*n6cDJ9y(0tV%JWw*0GHx z_aHzABbA46D*vG67Oi9JrO+fpF0X7;JKIzc4bN5)MhiFH)NsYg31s zzg&Xo`4A_2YA^ooe#2J^B961#nFS{iYhFIp^5{F8B^tDt`7dOtj12|(ig+iDqa-D2 zs)m`7X>uG}1aR8nB{hy9?*{!4X(kg1&&GB@&;a2G0&i0IGL4nYHBeL3Ptb~3;Zb0M z(ZirJv9nB3OM=wW)aE@Je|k-O-9!njkZP)RIr(s|CS@&98+2Kx|C|}Vrjc69W_sI*`*s;EIT4@H51J^km`9ryu0t!gV%|eH zU(?8Tum-mUf|BB88Mzt{ec%#|E)t=hnfWBbI3g0^mWE$%xa;k|1H-Fsgh>PqvrBru zQaspFs7mT+?ZKUSi4SGF?-R`0)kPV6peteAIW<>sAz;OhHi1 zh2U=ZM-6A3Om=lVo43Nw_ST2Ddyo4l^*`~Ost(hgf1}(=FF+Z{!$!>PbV)UkK5Y@|l3^uc9@3A~h}GfK_I; zao*B9!N1t!^KRhaK9}`(GsM{bJjf;=Z4_tj*_o8N|4tq^0mS*o6#rw1!;-hp50+Dv z7UrX+q)fH7M$28SLF}DEJ;H;b;_6LY_H<(cnL^WL!XR7jqR( zTm~PtI?b47n4+s+IhK2O*y96XXkT|(epS|-CIS%>oMk0;8Q#E!6Rwqcj)AMQ>l)!C zIGg8hM3c`TJi;*(X5f`IxX9Jr^2}c-ap^;SVnij$bHA&%gYV}@sfdA}O??0pP9iGH zfm1#>*i|;jMB&iYMediX!+af+&$bjwR`2&!n2kCGH!RHJS?F)=u*$qJ$5ffI%5LQZ zF_8e*-*$@gOEINs@L*M?z#Hm7tLFlO;Jz*pGc(c{7bR+0hrKuw62S7gpr%V*kDeK4 zvC4y)$ok~Q#?rT&O-du2OfQ}{{WNz99w)$W4Rt-N620uPnJ7YT_kVjL&GU0R?&}v@ z{liW0^ZmcJ`pG{KygvEUO6y0OE3Rp6KG^{9Q{+udtBznT*9Y-6C@9TygUELlI~TM zdGkHI2=wer-8@#5Bf*il`(L&{f;+a5x3@2LMaKfV%J=#;|$8S9)e7X?VH-EMWt^xxg4aJlOdsl{uIJs2P|7 zL}^?+L?p=CFkxu?D3Cc+{1*!-k7olf)o_qe%pGu;lv@u*Gu*ukPcQHhwB_DqvH@t| z;aWYe5Y#!Z5cHUPcD*oRdwD3<7XveagIp;*Kg?`;=i0+NE6PoFboOO0*1&{vM*8L< z3Cmk@R_4RB;30=c;>4@h!bt<){Tc#c8W`DW3>!hIY;UsFZS%e@YpEqV^}J=K*_dV0 z`R#tbue*)-ROeE4+tCQ}O3Tf#lPl$(n_ue6{Z9ZQh4|XtV|Ok1db-wsKYpGD5>&iK zw1Ob)f~|tIA|)nFNv)r++5U*Hhb*dBQRb`ewei<_zsl@`xXMG;1w#o9>A>*)*X`#y1|Nhf zm`}@m$#MYzH_%%t=fTGacR~*u!kY#6@j^r9Tc>h!?>`Sn8yUn~MmAb=fMQNGmdzwp4+XM|si zpDsLLg|B?~&Nw@>*STWLCj7qW$4_)(jg)HU{9K#79|)kJ%7$xH5=A|e=$`jWE83Tx z^ut+YJuAdn9jZ(AErn5=5guuHu}x+Q0w{q%cX~9!a5m3cc5Kem;Gst$8sd>hl8$+3l`cLXt6f!b1g_aait9%I^p;^I%=asIkV98_)>Qe zf!_M`-1OEnOc9hTI(yvglf^JaU1d87sx<;eUPD$puHRw>c3cO`QJ2X7^axvfJ0yU% zd?iiq(-h2=2@<1%ecSfz3L_;9f2Z6uP6fLO6r+1^HsiAQ&{wCtNFF`(a}ne4&^xLp z$V)NQz)O3a;x_0u(d*)+^_w7S4F`=cGg*}|nnVrvBD*XPl`TXWV!;`4h)d{=2a(mL zqO(z$eJk=ETF=7k`EKR$^ta_ZpFo#-b=92@FSRoc*1x#k26_a4Fy2l_R{ihjGPtrD zIGMb6J^6Oc&E9bnTwq=Cc(lJ#&)!h_oc6jVFhaPaliT*i0&XPys$q`f^BZD2@_lfm z*$1u^ZB)GT_A|5Ndk&Wt49}=j%(>iTD(dsqQ4WDaVw~ZigOHkPIA8N6U)mUpJT4k0&tS?1<0^ey9DE{0Dq4%NWh3bSBPc0`VdByJZHe}W z?&G)1)YSK(qfS6ep?&w|I97-)?>;3Fzpi8 zu;DJA8>wQYm1bG{t1WmTDWH)_r_)_^%{W6s>mEEQ+!7?&^-zlK{o+)1pdRWeXbn@W zr*iEdY-+tWTHeX~`^8V-7wUn(?SZ<+Cj%viXaDFMNH4UrxZiNjMWT#3Jj;mV_=+Qd zOWy|}&kJkh(;Y}RG#~o0JQ(wjmtRg6nDgK`=nE9!oWpEm;C6h^$k)EMg!|#^{svt6 z@HG`YpALg;D;F}Afx73D9T`;_!rDI+C;yimcj>sE8-0$=)HG!E9J!es~F5!p1 zdBT^Y_)ql5LoyvF8mx5aPkt7G7?KG}dc%M#(mrbt6{?>y^py}$*~eYzBVOJ_k?t@c z9-{|fnbh`Mh!_jmtOr0WmA|T@m1L#yY1116uEzgIlh28eGul?e2nzVzBk#_@h{c2nITOVY8wE#JyC|#h8HzdgZFl#e zlonQ(f$_2bxyc+sIjn!f|GPaBMx*?UyDv|2?tPsnhSOvPA(M( zul@-jsCynN9_Rjz01m>Tc512PpK0nF2hJVVa}yT0y4?87k-q}-A)Q@o0Wcs0jEA@H^wiTMcXXKi8@s+sO~sI_La$XRR%uQCeL#fbf2q>?98t zdtPXdzD*u9i(DKJxAW!ET5IP^07~hwf%B?_iW3Oijg*ge*W10am-(@srnh|Wljr;E zJ>vVS;Ofc>p4ZdDlbwETV-^1@j|KdxHPhSmbG$7(yC>)`)Y$X>h~w2^1?=q(-n-|} zeQopA`(Nl3IexH2N=a&GN-z&C6;A^35DNK*+!Cad5ctRlZuW~?L)nQB z&o7h;x6IvP@Y^v)Ja+MOoCj6ek(39GI6W!I64?6}1pkYHS0d;5+wH133K1oMda%oE zYFdiFMV;i^#)`V#FC63Qbi&(f6-VL0_#UB2h!(*q2M1PXaa}717g1R#2tSz|yytZzk5Im@S|b)}4B8EG~HZB`qNjrxSmX8URyf4Ips(g&M|FrT5`y zKFZcGgAzs#KnbIOvTZ_$C*cl8REM^q}ydd;cjRnqoZ zVMl8U30sUgUtgaAg>FvHZggzWV8{y5ZLZBI{3Uw_!19BJP;cM{X;+_3C;`H#oHn z$lHFJJJSZe^WPAfsha6!52*TKYkcLlFgkVYUT0g-{la$--t&J$OSkT~M;$QV)G^gNcb62oK zZ2Yx7GhO`xdhNbbAiV2D<#0*kI9MOdWfJ^9S*Gog|C#jQEexLY@EV;Z_wb#V>nD`! ztD5b_V?XR?Vm2{47~j2L+-4}(he-xr->zx)X2wB z7@yBDfA!JA_aU)}jG=u7@3vLYCu0#!+;y-I%aPun>I6JL6L`NE&CIh2?_Gm4O>u*> zGg>hOYSdz{E^swA6mM+kyf)Q)fc?tX2v_~qP?tK@RPT?#va4dfAzHPCP7jOY9jKcK`c37d+mBI=REC3GCj0QQ43nvV_FWPY2T3J;6MJTJ*XIX=f6w7V|&-@K_ zw$#2Z(%o1djz4{@)2&NUaJkf@Wz~De_BMV_JXJFZ za@1Y=dwBWfCd|v&qZPCVJX4{4*K}yzb3U5`Bc&F1?ln{f&ZtodzkRyfw{(mhDsLK& z+j}Z%>Kj~8Q8?2;bDEWO?Eb}T^I@FfA4&eyrByn9AXPiPRw=DqHc`v`IP0O3?Qz@N z`yY346!A4l3@%Ldx$tPoXhJof+Y;-@n_ji1Pep^yIP_Y>p>99!C z`2Z(_@}n}(|M!rx9YYdWa7hf&)}S<_0c&9L z$3Cp>%EI0tv|A9@O#yE{VYVwOTesC*BD5;PSC!teAhuehX)g_RwbsOSOTq&2UDY^P zpf&D|Jho7C%Y(WKmVD9LTovl+N=Nso)=U=sp#hX1iil<;r;lVZ&FjoVK`06gG zw%Y2JnOe7lrIP2e6ZXq0^_X%K}NI%R-j+%#!z6E8=_6ZcoG7#@qJm zf4YPeqP2@2duJD@-mcs&q8+*tu?eR_Wfi->es8EgY0JKR(HgG^M+=Amr)Sw;j98?) zqHI|s*RA^R8DnEyz)c0_Q>KKLEM-W+kxm~iY=>D zMiYhW`n2I6KLzMGHL4yf9s7%nJxR0L(}4Q(CsPMG-DMdpc5+sxdu{2Pq4npGp~wH~jqxv@lQo}WzpI9Srr$?6>O)u5PAAZgVq5n(JJsN#1=Hd3SSeCN1Tv< z=r&g+%dQ}Rm2A$IRvSw^9C0*miDF);d4VjjblkI`@QZ|}!@qnDU3hzJ zBCc$Gb8T<+emm^4>}b7+=D7p;F*{g`!aL~xY*q+^`ix5zh4P)YIuIU*+%p4%sXw=` zdV_X)o%#7L2)DOf5cD{ke(~`CsCo;axSD8d6n6;j?oJ@MLvRQdV1frr@BqQ>;O_2D zaCdhN?(XjHgg41|>%RZis+m5mr)N+1YTw=A;r`#8Rnw>c=B$?b3(bhS4-wm+-TlC2 z+-AwPx?;wEy5l^h*ygECuKs%l9Z_IQ#oL2X2T!~6=k?{D)lG+Ine}$(R^ZO^cJ&%` zTr#dPUo5cLA-uBJ{ZHK^=^=OwrZ-hKs;xV2aeTClSD`Odaz_0|cpv`5a((ZcBJY@a z`M2e?qyMu~iTl5^pP}ce>rOWnZXDw@pGVnj7}Jmnx{GXz7drhv*Yy_t`c+sbm>;TI z1r$+U0NmAnpkW=qm-P37SD^1GYq#1eb z1eEA_b)SpoZ4``r@gmA-^*A|@1}|(r6Ce*tu$j0Zm+H$i*T*m&o{Gbf%i$>GG%*{l zuJw+kA+D_v`_TIB!OkUdQM~P<@1`5vP7EyTln$o|iwFvfr&iY*_l8%voDFstayEU>fyBp=!Z}yHszztTRmWLg0WcW- z7;j$FEk4c(G8e1TYV)ZP7b}BeKhj(yL&zYgCxv`Pg%u*yIvol*2KO#!45$9@y2PAiDBhpYKD-}m1L4-NDsnW*}-P8Eyw`Cj6CIgA-zf8604>)2A zw@YM%O+E>3%ZmpqyEp}&;~=)6Gx`e@!f=P}79xa$&|KS;D$NYk&BmXakWOv|v7u3LWtNxZ zZauBsHW5iPziYYR6hu`rD$pdtFzA^7k^4vN{IV-`a$FwJGt52qe|aA>=DN^{ z6Abtf7>BL3*V&hQSnwUfvF;!>g@k@tVF8=X8qNQWp5i#w?=_4AnP?geb=b=-J)?;0 zf9N=D5rLd)fY2Z62z6W9n;MPkh)Z(x_$u8;!`)>zO!e`7T9!=p>e=;N=Kfmh@hvMu z$1}4II_Vkv%du8V(%)Sf*beWU-T)o7LWaG6+{TfzV)xk_Y2lEyLE+f{=TQ7L@%8>9nGVNKW^I}?Nmr3yC1>(Nh{I^MTXPJL9XU<*vjZlB; zzYU^Rzn6Z0gS!WK-4MPr3{m+eb)7=}v|Bk&A>hE#Ez@^0X(`OlIo?9GI6j^(f9k^lmf z{vP)7FIf503T{I@g*53ep3dBnm1z#X|1zXWVvn~0ySt*|C`Q;qj?3~DuM(MAPy$)2 z0ojsm19xUc#|u{mBM;#+K1ma%miz(71otcK2vi#^Hy%0cZXdfA^3pe0E#xFv4nIml zgR|z{32`btNUf*}o(N5H@d-`fE4qOnjtn}I6k9lKtItNFx{{q|ot>&l;CU3j~E^JUJ#XRGuf6>ThXA?Of3+m4cLz-aOU-iheSJ{pcV zSupfsq!gX ziD^o`ff0o241+J$1T^7>LQv2b)=c~yY8XecZkk$uYw$`tcn+&`v72 z$h+{xrGtIpFr9h3!^HgJpOyv7w<*wPXPEB;4`(lYYftLF6(>}@&lVLf(;FwLTtPr<8%O;0AM{t%Y7US(Ja3x*B0om@UF3h6WpsvBB#QC~xKJr21V zHO78nxuTZOmdvEmryN~cCIy;E%|HeJ78>p?Y*PbSpb%XT+z6}c=N>GD0`Ug_Y(bjoHM%6GjAEx^gQ7Bn@t;1ydsSn{+ zm)JUK>+`Kud5TgqFsE3gna30IR-kC{wd88!5LO>zI$6vwXIT-Kk*pJ6oI39H&udqO z?F0m*&ufLOiXeWx-CzFE|K#bCDsz1SEJYO3b+qZZsjj-5-9;Xauqa+H^|=3?w38dF zzWw%=NoggP@k&p0gA}O8FXe@I0j0OtdCZ!h$akWdohZvSRie`*>be`PCn6li`Q0ON z3fUDFtjR0%21+jv#C?&{cB6HSno^PRMc1M&U<&mYYw5oe6|DE*6BRvWkBV)T2*pyd(KmLPUXD1N@CCsGVV@I?nATS!fK*lJ)3|x3E>^3JqmFQ!a=)q!tDb#Z?8QirWLwxhd}fnbW>b=5WAEqgKkV*L z_VXF(NIa_9ii`Oa-M6_@yD*6LWkz%Ol%){4W(#=*)+8I)$?zX|&V-K4pp0;{8KHw7g8xC01khYzFlWXW+*=jnbufX1tuWii9sRYk>-9Q~(rmgDY z_FQf?{ML$k1AYUk-{+V7z_3{D$bV2G-;x*;FNWV>P78{ScthD?PUeT0sDafZNjTvk6a5{@;nj_G(dETYi+qwHVmm^!oT-=_xcuJ=o6W@^cd2Uzwh;G+%KW}6APm~*H4}0Gb8rEh;&Ys%y ziem9sB2+<;t#4%!9m(pSekv=?-&N0!Yp1(z!sz#WbwtVkGFlh9XqgTW;~BI3d>1J> zYBV-A67>7i)vlDy$SUoo;GXri_4K~_%`17pi?K~pSH!h&nCwd9ip+`zR)Z7G@iC!} zH4-ZiCeIl+CQnvgo0B%*?-U_5yZdf2bL+>SwXMg5=fYp~=Qj|B6x|d|e6b{E5UUHw zVcgUDFrY+OP0_E|WL-vp3?K9ebZ=>dxCkr>u$$~qvJs{@P_IaU-pC|hVq4+GOV)j zV^7qc)=OflXjkPnzRM~8lg!OyYab-YKUl=arv^i!R^;SiuS~#TI&m3#OQRkU5hkb$ z@#wDzl1L}kWW?HTe${>|bW(qn$Bkt@>Lw+8t4@4h0F48%Lx=0H$qp-4qjBp zn|y&>a`6}&M#1nhMg|M}y$%Bqd*9eRPX_HJ&ZvZaSIW1;1ZjX{Ze z$kmONC_8IoG8-=*M|Yb}9wb7W)`pB9Ha5ltwxYbeJSPae8r&}VI4RIqY(I78te-Zy zrous_geCGWkH#z?aIH)K9B^Hyg4$bJ9)ZVEZs6;In#y*)J`Ih#KrpzU;KaS_cMUpx z{GG-Sq2I0V@4fIRVm+quVm{?^K1^r#;Xlwk;JD{@k=_k?GH{)9JdM_lp*+((v2;E@ zvpwrj^8xn~WV}G%6#N3)K!xC)`~%a$ga2!{XQ(2Xv1A8vM~e9m;trUO=91(zpgoy~ zP@NP7LmA?{(kiQ(Q);0A|6%dRr4HuhNd-Bw6n^%-bG;Jo$Yq*X+{mTn=XtoDq-jl= zMB%QQoarWNUgw1L04m0MbgQ6{biVX_M<*M8ZF_z!{-3<^!fDa^#`gT@vlmEb3MZDf zniq+xvT^iAz)JFV^0uZ@EPvNe07H^!O7XkTeh&P&&G*KdG~~$XNGj;T{ zkxgbAdp-O-D(AJs%~no1=}YDv_c5Ulc(a#3K zAH@$dwk-vt8CLDY>+=^^1{gINFt@LC<+j~#e?}>}-GT5e6<|vVZqG@+su!r`&nyvY z0J*hyf|~+c7wL991!*&l`elJXCv!vvnVA(Q;O0ehaiwQFo}$P^pxdaNvz!xI5w4t5 z7NjLR5l^el&>1cjL%R(m(a25%x$!VGX4T`mcAVCnTta9&rYokfqmzx3GGM@nNwac> zey)wFZT(OJns?7W6L5G@;k*=?j{NpHMWg7; z_xaAc1VqOjt=I?>v&ykMEh^1z4Jyr=lBE7J+EWIMRjxmFtpi@-?y_mSk{;6iysX7Qr_T%*A# z{wn}b^^+(=ueU~!yt66r;2=Y-nRc|PqCp;dseRFvM8Dr2i9FrjGd=~$O7#;sl-O3C z(i?3X#u_B{^#wE`Af{%xh5LPSoF=?a32+N<=Taa?en;6fujjy+6npZh6Q@Md;I?#f zNH#IncK5?JAL)#%mAt5;P2)p%U4LEux&9P`vYj>_CbH?=- zP2C*D7ItS`PjfSa6isuDU|2TK(U(V;?Y3Do&7p^5mo~!r?`UD+aYU8cmN3MLZ)Mcw z%A+C!i%o<^W|jWfm|Q#Q)ost@LzdJ%f4EqASa~$JKC|+Og@y`HJEbm>a-RX*XZ7MM zR@jS`*NIh5L(7fJy=nELvS-{4pr32lJtI-I;U%MR#~4%G1Rx?p%%Hrzl5kJ%Deg0F z`Bmx0WeF_VJnB3v4srM(YBM6x@>IXUuCRyoPUY1ol=z1bD`P8F!>{GsLDZT=5-}y8 z_9o@a!c#w4m6ZwXn~oUEgZD0w;YPbyPF-^;Q{z(mZ24D^00;L2o{ZzwUmxZ-gO>$L zC98mkOnSoh62St#H?z8wr?vxi9ssMEEp zymC{YTgjZ(av|N_yVAQdJIUaqtl@%aEKI;B3Di!wO_F#C)aqO~B&p2F?0X>V6--D? zf*eG#D}h=_Sg3@~shqiR*j_5?l-TLAyhx6na{1ToyYMUzW$l(m2Lli=##+1d_W$3Z0SL*FrR@~FgiD6 zds)A?aU_UFizT8^Bgs=*nBVeQFS0lAUCf^BNq?mGgx5r8e~r&yBW2?2@z)ai1Y8L? zQD|8Z_C#mE;MeP_Wv1N-6x_foYtRQ5keByMAq4O>O7qLbcy8cItF>V8a~CvWQb4Zf zLdRX3%hV4t&8!2_7tu-Y2k!?lDQ-x0Whop4GI|AU2$47mb6n$Cxg*ROn*OZ@S{TZ6 zbf`)%WA8z)K?rs#Ln;4g$Pid4XhyUU2?ug$3O}J6Aw0zFKpfqGccmy7D}JgIYQ;}@xJM?GgkzUxo1)aR!`LMY z9{fKJ&RchA7AhxXV?BF4(iOax^-6BQ%UpV|>}Gry`d0*Y?TjlJSE_}{_geD`-EZ^T?%w>Snko%O3EQSjC<>CfA%fW{bN>0i@@xBsF7TX7B8QEA2v(d4? z`}jF*4Wp#9*h%W!JxQKp)xtdS%WC|2tuzD%&P=xR_DNgPwHm%ia5v%l?fcb&u8bZ=n=cRsMjJ-kr~HEti>yO!nS*kRJZw^A z4&5A-Ww7-#%^c;NDllSDUGnKpuF0s(l6H*xTrSODuc%Y`I8*vvlgp|z=DlxVlzFp_ za0a~m-6R_&2W7Ph_QOkz8!?TRR)@DIMl?qBWCh$KB{>!Ovlye!MS1;A5Q?_o7JG0s z>l9mYw0P|MQh&Pw<4(3b{a!6eW#+6G%DG_?jE|2rf^*`Jl0czkIz}n%9OcZg0Eg&< z|AqY5PNXSu@Pox~6d!)D;S&eY^>yzDte>^nd3^dV&on>dR& z%VsuiF&iZdkd+Xz94sU6Ea+8JJVHpd9c5cJE->L^hVc(7!qihS#66g1lY{j3-+gLN zF2bVJ1tkh#r^LaZDIC-A(Ux)|CqAAkB`=UzKP=1qwf*LakoGj)yz>7kY855_r>G5) z)L!wSmU9#XS(=ZRUc(X%GMHTyZ#ndug`X31s4>zCN9AC6=3EoJHV`&MZTx=@Diy5{ zkY_%8+OZ07&(tb76Gc`hC=4^Ci^h${%~RmuA)lh0!ffVJiC2l0P=}j>GE<3(lm4!9 z{vkl-+bTp({B#QCAMtj!9h59b`sWGBXUVMFt;NbDKx?>FdJziM3)dFcDrR9ZcM{WW z5A*v_Sj|C9p8V9@1L`4O7Rn*s6!`yxv5Bep0L7a^?cgK>xdCC50Kv=iC`nDeisOO z?b0^`OqHK47Vf^Eb3gpCR?=uX%}{%rwzru5b}cfylnDiLt9pN(nS2G=9zJJPN2g!6 z@tEFW|N3z`vO-?4yd}hQ#5{prVR=zY!%^gZtM;yFiD65tUA~SjaFV~HPqWlWy7l@A z)??h~%u!4vuPN{w#SvN8#0!T5AQU)kA+@@?AwvEpSf7%$ta+D7LKO6&YhN(mqBJID|*N?}J( zMolAuMoD)k7C0!jqqeRF4nZt2CiUgToDvixwu5Um#R1|1C34k4lL0KrRG55TX{<-y z60AJIE8je4m`qAnR|I(EJjt(k)0Lh@BJ1=2tF!QD+^Ev8mB6Xn&pf#LkJ8fLOJevD z`1$Sa4-QJ{wWk(CA`}nW-KD8$`S~a5=+es$4zO3Bz6w;Pqb{JKlFXo0rIY+&CU}~R zmw28GCRFnyA#nuk7bX$kt$RC~p7x&0XOT=O-l4%RL7p1#2#X4w9Qgg(U6|Co=$(EI zAt4b(BOh=_*!%dN42ryfDxo(VjhxQq=av+F)O2dmwiF$$(EQHHm^*@QB%d6=GqJTj z!VdZ%MU;_V3AzW54ccRMg5742PyB zKD`O9tLI~S!5j~qVI8T(4(``tfz+BJ`%?F&hjZtn%ysnwWG~Euy~7RnuRZW8v6=D$ z0uarA@-P6;@U6*{A9e_>Q!!VISGMRUZ1Y;0kB=0ITXE?gDMLi8YllO&#~FW1Q~wZI z*>A0yrBmFU84o)x!L?)U#L^$R4rnC;B+>=nbU_KVhk^64M7#}a?>7_I5wPe7(P?Fb z3=px5{ShIg#bJb~4LU|tzA&q-5!fX~VqZ)_4*(_4!Eb`$4@xDo_9b-O0T}Bbw2{jF zk%qHKc-spr%sw;B_5B~WobctNVjove=lH`ND`qDFLF0Xe+me3udRE>pnO3y-at!t<&Fe zOaLAuDY!^8jZx=Tx7mhfhBl<|H3c}MpqCIL^D6TddGXIs7xGKq6$M5j<@a>2kG~I^ zmWN37n9ZL?E!K>U6rZD}G~Cpe336(cH|O;cagdgMK-`6|>*qWLdiCcFd!yJ-P$O?9vnpUi1vRm$%=k3Ec+Xx8A8{K zRTOU*%C_9D)yqzddcvQda*}2Y_F%ZK0mHKg(jF45#i4s#fo=k)T!(yu28=rTi*9>w zUOa!+v2g@Eh~|U|*eyV3C(uxqLiGK247gZ0F`ErhZb_j6?1CV%H0=ao zPgQ3LSxa{*6t>RXPlR7P%^O5uE%h5?vYmX7!NiL^)>)-P< z9cRNhj;}>zt{+84XSqnEHo3SB!~6#s(4MLAQ|^bp0`TJz{`zZptRJ3@7CJ}^w3Jen z7D24EIeRM~*lxD+^pI59PDD6C_-n6}jQ1RGAI~Ju)EjL=quqD(QtsKB@R~qpL~$#~ z4xlQ#ikKS}{~YAE($y*xd;9#-=YO$B-gXc)x9U8>k1JwB@?I{*lotdb$?@l=R4?Kqg`?4*U=MEL;n5@ zesDyvlZ%0k%pMKBO4fAfi2QeeP=1o>d?eJ4(){CNFkZNx@&6*mP@97djEVxS@NX@S z?n{N|VrAJ)dy-(#h+OCFNDhU@;L)(j>A5kw#ABxrg&_4@a7$Pec5L}mqE%&k^@|t@Q3_{wIiPNIk(m7q0D0jLT*v#i0)Qb&UR1HxN0(^p=O~ ziz=tb)>nu8M0x#W7;$B({s%?;$6Zk7r}BWkl*{vP`qp6rp6eF=JgX|u3fr0K*6lT|H{OFGPPNQnxId`L#ZxX=1XC(y*y&U9mFi z)ywb7w#u{?IvZ4Y&!H>1=v>IY{IHV}(66_u1iWzhCoL72 z7ud|tXa0G8ld4KoH(+|Ku(4WJUlVP4CNW$n;PN3wCc$#gcvawtCm4*6^!yev|g-VRP(8oxtHhtlkRQ!@fkR2#_bN2h`sh9GxtSeCV!e z4fo4hJyx@@7AtV(?!L_Xv9>|MxKx#prAa z6(efnM_J6qfw&bT8ekGJ8KMa95&seY{)@L<-HMURHvSnq#y$Qa{+DR`FpIFKq&SNc z8UpKRMq`1Q%?vh)#vSMX5G0Mg@2nG{$|{Zd4`uAmjxROTl3y5FLL$pm;oc-bLqh%k z16qI2mdXA9wp7K63l~!X(2w zlX~iy49_AGQ#EtyfQ*rwl4^<>X4H#cmSK!F=_ygQ#HeWPGoJg_q7f%0NF5K`o7wSd zSffsJkAI((N0sQNa3Cbb-_Iq*|BI`UhGg0~Jf6D12w$CpH|t^%|L;2iL|z>uY9krO zTMkKUb}*_+OB+K}NtUxMVG@VC9f@qXa9vCV)24(Khi2)w&GUQ)MrEc3M}wqk_^}BH zs9fbR1sCWL*A$!!1E|xfh%4ZH%FGC`J>=3IRLstu{6~jD3dMWhJ zIrxzD#cjRlVZb1I*n3no8N@soRVaogf4+cgo*u{ zS!^U|BB&$%uoAWsHe6qtk{TTs9j9VBJZL;)#oFKcbQYz;u}*}O?;|6jb6S3t+Q%rz z%FfEZ-1uFy8d~m85lJwSuSaIxRqE$wr=$CamnrS zvYH|*&Xqku@;>|+J5#yovuC7-^N&oQ7&pt3mk2inX`cb1fFMjch9^QQlHcz>+l3!C z_E%m~5^WQ16B;$5&L>5w3d|=V6v|kk`~qY+e$`Eha(r852_VbIo@Y6-S_%IP{2#VF z!zvMjjYP6w?EVVp&9;o^-jZeDv+5lSB_!o)9pGx!|6@{<6Jrr(p%4|2ZlPdm1TmC! zW~{KlBE>A_W{E4H9u_>uN` zRGf>3XVH;H(3*qk27C$T=e})9DjGLeR)ta9JDqIDCChZ;<9q#m%HIM}eJk>Qg#I~1 z1O%4Rp(nG&!NB2rq>9V|_%_A5J^xmN;nkGG`XXaFFJH;IL?8ecA1c(Ip z_`>nxw^R>mb^=I6E!pIdpqSmwEz5yZ8EMj@+>PJtW>IGkw3qK1)_VL)cPGEF5_oT^ z%d)(Kd-|gLSg~HJ0kQ+r&?4yfHf0Z`@>Bot5>W1(;ZW`qR& zSfcqPAi|=QddXRH_eKrL+So|P$nnPfXSi)R&JAIY9d!UhOqgxxW)rg~!b8Rsdx;vA zv%2aJXf@om@KBWT0F=lUmEl#HC7C699;@DU3#Nx)rTm=|3^z7&XBibzd6l(}8cmfU zu6{1spefsMl^&z5wATjwp(Gd@q@ko8ZOadDKy!2Eg9VfG0mJ0yrKQz=mi`kWYj*V} z{04kGIRhDRrBzeV`V3K&6d!{z6Zh~rB)-?~0~7;naD5X2PQp?nfo;KxY|UU!O>}4# z`O5T5sVp(-Wr6$Y?1TNLO<|lX-`0tLhN@o7{Ru+3q+T)o4|C7s{hRIDMSi~e>UcFB zVC_Y|PdJ!yvnwI_!=`t_O7aCn1%WMyU=nf?@}lz>Lc)P4SS@cRqh~QkBw`Nqg4mxE zuPN}6v;QqF3!w)PsY?ONEK0vq4T1u?Ad zM}!V_$4J9|I~L433bcgr&H#R6rUVllom4j>cWO*9B*jUL%iJ~)pG_#y%*2R~h7_2{ zzqnfy*iOW<@ojaM5LTFj^Cs9`f3PvXesWeu&QH#-4DAw(hQA#u?9(srKm$MAYTRQ>j*np5Td|fE?bOp9ujR2muWrtHo!}tJsGcmOvfW z5W0?0niJkNQK2828TjStu1_+Cb!*Gvn!TO+owAqrH85!VajGm+>oRI^@@Q#(jG=uF+YraH&yLQu1#-PfXkuZkIjw8E$0%qd zsU%}7mR-`mPe|3?`rlQ5N#Z92U##_m(~fhJZ>d9$%(5caHs3aX@#h64>d>oPZbUzL z*-~SJI-H*nFU3dMn|Kt>B&e1c^<*$SfWr^_(?z&cNWXvmKJqB)Gw36bU@{SUcYV0H zZK9o-GWv$b0w}leN$i(A4pe3;*#FYD`_9DQ;`U`K-7$kq37QQx)W!J~3-xD>u7I%B zOj#U-)m3ChdbNUY11z%I+A^q_CS(c84omV>0EZ@I_?u*K&Q(y3TuyGGq&&V@+|xxI zxp@cua2vFg6^_&>?wMqMr`5)zt?!Ke_aZZ%lz!+;9DrsKw4p4Vk%_f-cFK*kM4Fh8 z2JSDuaD{3!VTIv*YS1oXMsmGe=FV@8MC9W1( z>dtp+0GD{Jq3;ZOzuOB2zYl%qI#ImRywVh!6nQMobFa^%$c(pgmgARq(U4=}IV?S~ zcf7U@4MAYwUMy`FO*mp+EDZ^lb4ak%n4bh2_8M)m$g`SLn%?`Yhs^1H=8_WF-(~+M z8d8&2L#U+Q+y7WlgZ-UhEN0YvuIKxgw0yO=pc(v3=0|CWMevnS7LIg_;57R^tFqkk+$FZ_Ihmu1vB;YodjzDM?V^n7)t96neQyBv9h+e(YWc=vALj*r59G#x2W7G%&@ye+am2B% zlL_>X$#mdR=oD5(jBBt=n;fAk8?DRH5P0l3WG0h$K*Mw09hBIMEP~(H8UNQz74ff>wY%|52JSAb$M-LT#5$KY__PcRbvKKuf#2Z!j2si&x%Ho zcg(t9B?U9tCR>Y{3y{$lO`eM~Fd)nLAc=tab}+p+f7-iPn8->S1t zrdC;w1i4M0Hg9)mN6ngnwTc$2V1tI2yX4^(eR=NsarDVwrS#~NNWvUJropE9`W6zk zi){25R-_nK4EI3^Qsl9doSu#;Lorhsw-gNcshf?HJ7i>Qw#h5)u; zsz}D`{$#AR9uK#H=>>X&VvmZ*iT?ANAZ1>BK_23r>B$tcrfu*J|ZBMtEYxU>~T^!`8~ zhYA(-;|Nze_@qiXehoGWl$&Ff)D61n~O zBWY~k9v`gNrMEM)nC|wMHt$h=^`GZjan?%2E6aG&A8xf}EvrMCO)@x$Bl{MiPwlEz zd`~I`+9qz z#n}(>@EJ+Gzl6mQ8Q`PYcb{{Y93^!x5I876aU0LVSZW<5!C1mrGD2}T5?rRtIG5o* zzXreATtv_T9@i3_f+-uGq?K*8UdLFW5y0yQ7Mtb9O}zR?D?tlUg_a6EwGloDr#~1>4>H)u4@G;eiwLl z%rIsRt;_X+5aFkPMx$FfA!2A?HahVr@n~;1kT#-`F;ZjtBcTY=U%#kXr*sLqOZ*B{ z`SG{cr;$02`qrZ4i^-7I1D`cWBl1FHuj(0TsOO#Hn#p6CvKZ@$P-GqVkK0OijN311 z-N5Tz>L>$oRbN8*a4+uTntd;BFYaBxZACCkR5^y07t72yXFuF2G<|X8p}Yuzwgtk;RdZ zD3)DUP{D1&V>(Z)J>E=1$b`>C_tI$i6yRfrFk$HOoE&)mxa;(Br3ce;nR(lMR(BdI+MnUh@6I z6&YuqV_TQc=m(TuFY}IEswPMChVGa2d#+VBJVN)+ABf+j1J*OkB=^6ImQN9ZJc&@6 z+U^jcF=HMg$L;LmHv!OVg& zUmf#}g-7suES0i+Pr&h4P^W6_z09}gONt5hH@{#YQLrE_S>Vg8G2gan5=^pL!p-Kb zQpDKbxij-aNwu}g!Xfh!{c7NvA}v88Ygu9Qlg6yElv(}Z(Q^_ClU~@32cht2xKM1H z+oEkGk?!@rUao^`qr)4qhgI0q{2mLysqA>&{LcF6a%p>Wh1qH|0=}l01R(yj-IaqE z=)XGDT`oL(_&udP3*8D&i86(a;#C=ZS@Z}z#i#rupD1w|iacC>K6F48p~xp4ks==B zi+KnnMPBh48CaK>+8NYjH%U`&q?qX5O!Yo_7^5>aCis?p*u$>-bo`i+M9xb z3{tmbSq3CkfZdx0N!9fPGS3wOLFf)bH91;D=ng6Z9-;_EG{g&A7>R5)uoOLtlH5O% z(PaEWMNr0SG1-2hNBXd`;ptCy52-LCkoed4i2vt(uQVze%3Pf{-q4yuQ+dH=A=zDp z$B+6nrMTeL|7T|o?*L0+q@L}9Wu_BAXPYA{5no);f~3ya{!1A|D-zr>tehV*M5mme zBNv~1D6ZQFlTfItk}s}nvj3-0HM{(Z3Q#KoXR)xPZ>G)<#5jS&1c5_Cl2={?a<^3+ z1JAXkRs^63z&3}VS$LO=f~o|tikK#Fib`gc_*6kzB`>-mGwS^It0O6uH^53lQ-Wkg zNvRf|UQwayr5uZw2aO&CgsNJR9GNi$gC0cvi2_){*rMjQuh8VMQN!!`U|AM%eTam} z6Ng}cQiaJwka6&0D3uH#auBa`%ByxDO!hb%7V>+J^)N z=|-p6Ce6NLirnC_AEWDB`a%y*eJ9mon6>bruJ;g;d%zD0fJ{;tiBwYfNeey)+-_$G zpx6DYUippjoYsn;uaDa|*0)+2w#+HPZ=xitdt#6VhmY@&kB;<_j*b+L{4%iTf>;rH zD#~cFH~o$y%%Jvc+x(t?Hs!gfkZtEmFfMI`HOp6iFv5(h2}PvawHJhkV)~X4L;Y2Df>!$bqnvl|fzEL>c9- zM%%lZb>b5lY8+MDwtWeROjOB6BoY7}3o~vcOCvxYq^9 zrf8_8PLpJnggC%An_rTyW`FP6_(isFhE?Jkfhz}&F9)JgLHL`*# z$TQ&?GmOHWQ2)bf^4C}{Lbhk2wC|h7$+oDr-FyBm0c!Y_W_UNy)xq>F5f$@M(gp_w zT2S{|q!uhT0Q66aNI&DF_y5ZGJ!qN6?>#69TuG3?A~zRsnB@SKlINlBiwhwS`R_0y zc2YD&>Bz8BccAPbo4j;H%fqPAqW;>KBFv+} zj#e={)*3|R?c=K0_pK0PMQmxS0#B?_dIcu8t?{j+5VfQ`%YFF>j2QUcibw2L^s4o4H$$c}M&Z?nQ5Kg)pO? zUoyNO&2;2m9-n-8G#5%itr?b)GuxW{uK|lKg^%7Bc^5M#!gF*Q@w_{8dS}k^k02PS z1)!q9e=WgSpA9QS5h+YJ*!asFNaTIf>OdC^m=Q+X5d6WU3MN*_f7EdSsD!6rJRFot zWe`-Hj~rVDZ%uZj=0&frNF6WDEq`Z`Po2Yv>Xvpm|Hm_-4CE}q8hgd0F8-ex-LVVQ zXbf1u#PXMEVvc*HO?L7Qz-+?_W@lSDNs*L$T^O*>@aXDhF6A7~o64g4pI!L6?&gdy z<9fvQ+g*L$kHA%**arlUf~#y*m*bh7O?zy96FLNvH*QW8_YJbOqz<0v)1%4G*2Brk z=xdC($%49=>2Jq7Uw~OMK_pUGFbQlD7;9URm|7Q|MgMt z>de^5m0}_AoA0Z4jOV&W`~>FfPsK6Qu>XoO0Hynvq6vao!S$XgMU7|*YzRF!J28OE zdhyX9Y%^L2qAt(JtHbwN1B3e?_k`7zjz-f>Iv?^V?M))EN4S<#WB62;Aw2hFc0bh* zJO4SgWML{Ap4iI;vSYhljPgw(_Ch8ch;?9lHljhE41LThe&xj(SG|th5dlLxKrW~B ze$R2{aaoMPt_ErPNVHGW($GgzSq>tqp1h^kAymf<7xMXP(^NIh0&pHTU$yWd1=or_ zTT5voHgo@SeN-sCFe5FDf8?1x%U_pgsNWu`VqMZ@a*Thit1Z}{7~N+QY^5($DBQ6h z>78$8vu*kO?I8r^etS}Sy1-n4<=5Q#SDrX6AJ!=>;lM=umu&wsvk-$+;`u!E2cVV4t*08oz z4(P8l25%0_5~HKVrL%LLBgLgJN&DP5&sz}qkx2X_gqf}h@bODi$<(OtRW!FVhE@B8 zf}ci|^QJ16; zDw0;aMXF7FoimMUQWGzQooIs6y~I_fjD!X=pwyxaA5_v6JY04P9_3UT3wO>c{Bjr zcidC%4?DG*zIW5{IKSAQ+|u5wvN@-{4n#~ZNhn17e_zN6_s_QE1^<^&!37|li63MV z$U0ING=h`N!~rrc=chFJAJM=z`RJJBHIak<*+akqEY_Sbz*1x6b8A3sGHhqEV#Ol` zs=$26N`C)c>Edqw!X4Xr-SF+aNF+n>T$A^0rLaNZ3_K!V##->L=cV5lsrmmHdlPu5 z+BbZB>_V0p`xX*2_O+0$P$)(-)=9_~LiP&Bl5K2B_7IZEo_)_6S&~ALJyDk8l|q*P zbJY8O-|zSL-#(xByv><8GiJ_tp6j~q`@ZhyzzXO?N_~GLTdtE7^hGeb9hZDrmzlZP zwLoKjJEIm`Lh%P?|1vOCvEiD%A(#3|VDdFL18xHC{*`UQ{rD zCxo9?bv7F}kN06+E&h6i2D}@k>_t+4R<(FC2v1&5?ZGs^l+rd%#tkj3Dx(W;DwxG= z>%Dors6cx}rlT%{_EgcgN+D5aloFh6u@tuW3D#^?Y*-j<)?R+>zU*q76`R1sR`V+{ zLvA^%HtG64OG-VS^e8Q31FUv+>COHiDFsl!cD6dOoDCWdcL_MDX>$0A6JIYZjFC4? zAnq%hKb*xwDR!(9_>a{3fJz9|WT2xu%^H!~}jdWOP z2iL|=`{!5AaHcAr0d-sUTs!9r$U{_Z2XMNE;dsg9kJY!T|Hl4$cMx!gBfa2(>yLsL zbsv8=8=q=A;H9=E=a;#6H+~_jKoH{BQg`Z_4GNO;CAof~O2*`YE8m`ozud3)bq@s; z0xNKPeq%#Ys*2B9r;^q%F+ks6V9(dhHMG+|@To~o!ivjF{*+U4`<^m0lV?u*4L)Qx z&*_-=mWcl_fe`_|)`;iIoEl1*@LRd{a*M7%B3D5PlTyG4)CK`0kiI4C_u#bAnGEU`YwUii-(1| zVIQ)(KYfVRm;b?P+WPXl1td9WRRrnajX!z=o}G3=4N@i`08vG3AzJYxa*yZ85T4?x z3<#gBu|JqA#s$EWB^$eNe!z&Bba@sY^VlEsgOXJwjR$(*OKCwP?r4Wb#YJM2H(V6-{dy3syb;S zb(jElGsO!4fJX_+hs41<4Z-f%&RZ-3pm(6QRXOqc;k>* z1m%of+MitMi@n+X?M{ii-@)ET8n?VQ7p|IX2hQ$_S7#lRN8(d9U#{1W>FIBh)XQk< zBBWZ$)q&ya2tpWfKjiqmqSn@9%m{sida2W07r)0Lc%%u9Z#+KXntd!~n%;>{b3`Wk zby6Ev_pa<`{170Fq553mP78JI7h$iE&}TwzP$rFw7vK)93>G(%M@2PfeV^afe^kWy zneh5=Rs31Zbs+BstcsZ$bd{@Np#Db*fBsDzsmlf@5~FH7OUh=}zgQNZV{915vj>53 zTfOSg*6+Q6QT;;{O1(q%HWICL;(89Q?a-l$KKv|{;LvXpS|YvRRa$>?DV4SrUvi3D ziVgmhg!;Kf&gp}x=!fX(_1v~%&AB@feDSPuqcb``U1iFyT8Te8VMGboL8J7L9B|q# z6do{JXq5IGZg*lwqXMlNdH|&?G~RN)KlCa$Q%f0&_VH0@y!HvZ1;;qJ!RP>H?Z=K- zN9gFFPVi6htmhv$vcmqJEbv^>7=Y(WqNqFFf)OKHHZ{5pZ{xerD0i0HHP2hTf3laXWs?&F2?WTr^b(eWm6pS66OdPnCup)xOaM`RW&z z1?HZT%zg8Had#%(SM&QmGh1z|vm3hfWZP5Yg~u#Yk?nH3PFmjy_W~Q!pjXHaQaV~g zW*bv}L4YA(t^>A!Fe)}9be_TSzqwy~S$0VQZ z6U&?6lZW%60iF+D_Mtk@NElztCB!cr&FQVG`U=GC^-+%<4=7~gg>D*|A6Coi$RF7~ zN=K)yT4+56j+NjOj~e|%K z|Hho*n9=*;0jWi)1>9PwjjYGhYH+Bzb+NbUB+Ju6fxy(|N2&eDc&0O5IzY8a)P7C353ID3}RvzVQL=gxeLSsHgdP9?Ca4 z!!_4nCLiU`u2q;T!WxfNF~U3!(djA@UO$gy-u{>X5*TTTbEN#j<(-1yudRtlAV&SN zf_3D@l>Ow~G*Esl@mLF|-Pb@ogP)F4Jrx#5h*HnVdyPp0Cj&l-Ksdu{`ZeZ2DVA^( zcelZ%Bj9D_n#{AG&Cp6+cWmjlXW5X_7&58GErewbLwWv_OK4DrsF#-tPwWo3%}#Sq z{a-wioc(lM{(rP2wugQb%u#w=T_I`1$eE4OLae?4>+%r%%{a`F0aPd#6p) z_5P;4)X^Q%Sab&P>QBi8J$_)XQ*tQopo~dQC-DjWG=8w=>AeY9<=cfkXlTqF-I>^< zN#hUm0Y9mL0zd3m&qIID=E^#cmJ;XD{ycXtuX%({bZb#i-c}r`PLgWRd7TZsp1)3T z9+3Qx!IQerp*0?gI6#|QaRT6hYG|JJE_X54JIlw%%`1e@+)&U=rO$)B`QG85?jL4< z?1rT$cVce$1{8$gIX3U|!o)MV!*4>Nym2KRv7tcIB)|U2tOz67bD17MTkk{~zsYwZ z;GKKu$(_#_#dD_o?;zT@QMsTnJlslJ27Je{3U+>`zL=&dHnCl@g+y(=LQP z3wmrty?~M`zxyXraCR9stamc?Ni9mI^h+&bTmWi(zV{KDM}r#H?EGNs0kGYBzV04? zVGb`l<$?A-WEvR2gcL9U$I{U3^)k>IwCo(bkDM$tPO zb~SJ~kYp^A0*o)JSf%r*o)yxWCzQ3qQOAFR4)ndPsoCzlu3CNnk04coVd})`(UJZ+ z6O1O2MKN-0b2RWi1Wt`#y(S*8!v$&W4>M>($2r1!X;lJV!~ydv_hHz_{goqA`GvT8^H!@FtdQq?oKBy4@o+0bapBuQ z;Q7A;2h|Wv8xgX?4wnsC6z}jqnL9KwwXu(~v6NYbqSrUHV+aL7h^&x;AR%Mir9>`} zA9|p!oMe1`F3=DwQka@~L`y4%z&_Hh2T@C-SVjo3G3+=wEs!nRF3idZV?`2r?~0r6 zT>sLYh9nf8F%HYs#B_b__gxDRL5c5GeSiCgK}#zd+`b(_pwSW+*4k^sCj*=BbK9Tm z@J#;d!YXHk<=jcgor^{ZJ+W#+8ezS2P>je(l#c@`CYY#>rHEo`A=*^jg6u7ZUNf9S zK2EJNCOD;9m(y<|uV1%2nyWcYXh8;`cZ|Q6JTm)U!Z~;3wU`76%2(KtRgN~DVj$NI z-m33;<$wp5jCEhhP~HT(t>W6B^!(MO1-(@I)VDX;en%O^8}u=SyM_=NDor^jj75!{w% zsj%V}7^f)s@hBCx<)wN-+s(Qwmo)Um4%h^P6e)Ui9; zn-lKeH{K4$A45j&jNkqanq4`T3+1ez>!MP2Qbrcx;+HV^0Ge|YxrbL_IAjt!0DpSv z$z+3LEo06>H#0Jv^FQJ4tk8P9N>lx*^An!ayu*3HW5PN*I2YZjxIA29-rRKOHT<#~HrsYL3RV)xB}PlM046+8f6#)?&nHWhb|{e;@urh%V~o>*LX z_uDkjfl>2EAeCd{DvfYn7Mg+} zaBIi-j!zXTpS>h~EO4d2TUJ;FPSpleG#kC(9e-r@+NF?(1`K0pA>bg?zS>b)qf+y= zSgzRw-5MB$s=B6yS!@|%=z*6*`<$hhh|?;Wmi)9=xrrOuW9tJZXKg<6C6O!?ZBo+} zx2Fk3P2OfQseKCzU5moekUxWXI}F<+28MOCF+tz4}W#nD@3;03LTBlLEhoqN$Bro67%=1yYSrxz+?oo$^-c)(KOmdHGWT}Do9nc zuv-6H8G-({G?JdJ_@^{-uUVlY>9SnK8Bv9;^*0{?F9eEXV^TTz(~yk0B=%i*p9h(> z7Wa43Nk!YT%98biGZ&Ebisq%5YGsg_zrDAvy);F#0*;PHqK<7Mnx2hELJ99)=2J}u zcF{f#xgA;&(e%*orzMpp$h_(p&-L*fYi)kxE*V%Cd57ueTtqaV1pF|kxlUrH0kMiS zeQRyRk=XmAQk#2E8i0B6cp**)r?D}53;^Ox2ze}V4tPV#)d zZ5QU52GX$Wxm6TI3m7xBCL8Q2E@hM?UTf43Sd_d1AvjN6*1deP zTFCavRdX_Z==Xqz)L>7*SN+40Uli0bQ;7<1o~ax^JBj+@5(H+_jVKelL;x&7U}LS6 zp|rAAMx^3)_{r=!g6u#cy`R*c?A@8URxUzoCAfn^e+Uj5iPu7{=7jO%^V=^x!9Z9}4q3O%+IJV$GPu=t)kI^PlTF zj)*{TlQQPg=v{@eIn9dV5UERbpT|GzRh7jDcmk1r?Q>@0}f+%@=$twb3QaD&_w3M#k45j5|R^7hZoV`D#;}z2lDD6{jCGL?lZ3J z0=QLq^OH{UOH$a=#SG!7(44sl0$q}EAmdUVeQn`lmoSg6r$^QE@S?;p1q0-<9tU+I zUE!O^J#`{KHcgpX4aUT{hJt5>#;!ZnltU|SR zL%hz4)!JcncMXS{sBnzTdQQpKc!h7W=siwPLIpiItCfE;J2=8#_b$r;CC$9+A#>+Rq{yTG$zW$x5;O_Jp|ty+yHXGW!vSg}fy zwTf9%ir9NLMj*i0wgY)_6?@!Q{W>u`s|0OI zSYNx{Y=v&u_fs6LcGBd@q(hilh{pNSuSE=3(yc2YbDxQf{|FRO-)d04xqMG;BzTAJhhU*eWgk_brrJCrjm3j2{)96*LaoQEF@#reH>yqVQdt)hi%|Yj)&9E-2 zu`q>-`H%)%Ev>+d?;B5l)L&aLC+qt7wi&OPyW?fuT>orpAm!K6FR`0_={-+>BmeSY znDHC=S-$QZdV}boI;Wo}6|aw;al13Ji}^O%QY|L-qWTse^?Ca=ktd6CFX|LF34&>p z_LT!azwBg@kQwP-N8Mh`YyHJKc(RR7U=ZTH_%Dalh`IN>-g3Z!EVxgv?gF`*Lj-~! z#e!>b6K6pZP{)ZOxpOk;x@O8q!naoQ{CiN~4^kip7b?brh_~_zJ<=y;6u>PNfy8ve zk?#z@cAB2Lya2rtHaY9bzWqm~(wrN~vKG)9p*$prTqT5*87tJ~)%jNJ!% z-*=f70fkkZ853lqn)GwOY1QI?^EI93^izK#c1o$*@f1(krLiNL-OrB>*t7qR=C=N_ z3~20s7P5-4@=+O6DLK!t(cy#mK;peF39C^X-~X1ObuX!ffnIQFdt>_$=!Mb=UC90! z+rT-g!}8bs+JbM5k1hpSxfoex#!ng6ybm5@6`#Eau1dmGf@Vy5O$z=m?_e{CC~m?a z$;y3dLByD;A-P!kiVOYGh`+FBA4O?ZGLX2Rl|JsOxxd?pjVUxS7nC{eyc)Mfa!B#~ zg$v7kk?FN{Ad2usL-Zunm^3KtEJ71|U5+9gC5(mXI4SMiad1UkrOD(g_o&ZmMG_dR z-SeC5XvWsd-bxjW{51Qq*D_pwC(V&4sr>b32XUwHcWI9P>_A42z?xRXe*%H)vn+Ht zeIoosuRfp~DR70Au<6^^7b0@nAw%l`DeO~L)K*Tf)8m~*Oke!1D@Ii`ymS`}XrT}F zIMG02(XqQHEym+D0MG-BAK^2Aga4ZMCDrWMO(*ZJ8&$7jTnl2KIz3>n`YY7%#Hzme zb^^>Ee5gQTkKqW#VG*D#a(4xm2Wm7?t z*42wZLuAEtxatD^Gz*pfr_NOIoeiL?k$>6_75Z2?+>9CE|NdM&Tx3}T4zvU&#ETUz% z@zSRM>V0jz-9`}1E5*vc|43UgcYV8B{G8%O!+ggP-a^i|S|ox`&6}`nX4mx~BbNG8 zpI?MVlWly84z*|8x%BC5{$Ha{wK~3tc=cXlgp~G6qLO#W4%S}mHjgnp)gjw>0)kw6 z-pU$n^eK)R+n_`ea1)p40)eO`to&-qTkFNxeKe&+wAGKr1-b`D{TxAutOl+@@z-TO z2@7?J=;P&8!8SzqoaWyfW;VCII_PQAO{&Q;b4?IS*kt{6V4cg3!ei@*kURYH2x}_* zf}h#^C2)rhKs#&_Z!DYK*W0^j+1`U4z(8fK{T%OUS729pa5MN%ZOzQ=R`v;3vun+7 zKvlGx~6E5TKGuj{bG)aZZEcsgyO@#U^cMz$GL zwiJsl_#Au3h;8lTrvZ6TX*TXw%=U@QVBV)r;}!rTZ~CiCO}6aE)Uwgrq3nVh`eHUU zfi}OZL%)vF|DO!BB{&lwWMh1uGt5n#5ebp=JSLwu7fmIf9-r`chEp9RLNt+uR$FYE z00lT-UUA8x6uAt7xA6-I8*YzhZ0`I z{x9h+tVd~9I@BW?1`JPm0c_DKF@j~Q`JZfrxUoV!J(8zTBuZ&u*W4Q%U`x~`GX*$; zyi21Qa2;9!OCIm`ZZO{k$Y-~Oq{i7F(?Y9J1L0}D4W;&<9Ck0^M@c7%rSsE(H&EpC zV)Rh1pQinn;s)ZW%c7gB`n-|S1x}UHYhG|tV`0DV&~Wek$$>Jp>)Hsb@sAL#)tw~` z2Ulw|kj!M^f5W{A(olt>!sEtZVnIbgW?z1)>?4B4l6x|vVC@M%zmM1=dvrq_b%wm3 zmArrM15HX-?TF1$K|Jdq2|29B$Sd7Jk^|J;Xo5dDX2z8UjE+YWF14G(3hNIZI7_DF z%V!Ol+}d!hDrpxm)u)mIXEyhS)(1ijG8~nK&AAbl1A#0$49NeaZa9X%D-8w@Af5WT z@8$F!wfcj)@Y$ls2{BAmrCPkG@i?)^kmB5tI&I1@2w zUlamfKjaDI-9ow@oKgMT=ezx(hF|8Xz_$X>T)RCP}S3a<(%14%@%=}Nl z@Mky|W%jwMzNAvzJ7v&kj){}|3`Y9D2Ex&!RJ=fwg-^elaRV9l01r46z^C@u*ajt# zfbb(aAvh!#jzfw(9R4*)pufWsce7o)guW2F=LS`>*S~Doyt-cL?IC8^^zyyrdg42oCnhuLAGDAe7<~H`^*>(}K?!|v1Cl(Ji=wI3dmWmgXtCiJ zT-F})a#UdlPJ3O6XZEVW6eZw?e>M{b z9_shbr`5=RnA6>X)H}n6loX~9eXo}{A5VFWjFwq9JMFO+mQQ7mnzxkuZ_Ug>q0!|g z)~oEJw9B}9S?lI<%cNr84Z20(@{mdXQFyC2@l#Bm^)cHgW^W?iEed}f;QRdO>wtTT z1oQDkj{LDFz^7#^A=!5SPZcGcN!}PPCC!dbx_7?ld0pfKc_i9TmVG_BKmIXC#AB#r zR&1GYv&8sbL&j@ zxK=^m09+z3)C}Ar?zUNe)^7tA9PbB@TJ!$+_<66=_*;i{>calgAT*^)Vf9yfU{wdz zTW>GeA!(lDbxsw<5uYs7=b?4l<61pRg;1>toze9@Yg$Gyk^6F_ZAxxg<9r z9y~KszS5_gZkd17c=8ojFcol3{xA>G`BIuvFN*<=R{2RSxHw)&ie4l7sSx~FKnZmu zp+SH*EDl6f3zAp9IXk;w79Bu(s?s#Mt#j8f2n(k2CpVa<9?MKF9E;MTNHNqtd=eo67( zq)>kOyy{~9^Az>EfI1%woKFfo2m;mazw(6OYB#Qj!9!fgLu;Pqrq+BR*|0h&`++(j zx&z8RUMf?8KL_?G&yQKIhk|11r*B4)MP74+#FHC&?&qteja!c+BZen@L8bd27q5(w z(Hb$e^*)Ia-96Iy-d;ftehS{|7C%zn0ke4XWEC~t(VS>-E_!!~-XG6==cD*j9*0e& zy*)9HKry^C4;Wpb&b;lDOWkiuMJOiP}Ujroj- zJIg5=ZVFJNwi9~XiaFfhxonhiPORRz)5{+kCt5u9I;TX#U2P*M$b+NRIZ8)28tW`+ z=-f=yFz5kwVn&k_5wxI~d{{39=j|HP80+C~^>IC|IGURy&3XxWns|5%V>S^gJ&#YQ zTZ&91DMgqBp<9tNH10_W^Q8FS`^Ufmx2ClaCX=m5ar+uu=-w@?j6TKdx^6>NbAE*4rhl5xuI>No4X+)tN{&v2 zKE9iA-51=?xUw^yHZ2&XLp*GH02M^@8Q5XYH8WI~3;$-=XJi-g)v_y<--M$FnSd5B zIajJgY6lOcbET2^9I8mXoo#*OpOFT?3Vt|Te4byqg1k8yLjh1B5Q=+Mp1Y8ca}z0{ zWg2LN-dcId?EPnvs6IBT0silqy%9f?YA=a%Ued|A>=W{O-R7N-F+Dzc=_k76=x&SoF*hBq?{%f@I^6}&JNCI7e;-yahjCSnxk>Y)nr!d;-5_<$;Z$-o7z_P*e8)s8{$PISl9@(U7HC5 zgr0{vb-$m;BeksrX94V#&adzgit3@>dXt&B4`NePetgBw7qtj5RVpqz5Cph4nhD@m zwBM2xQ60Y!-^hahI>|4=$QD`j)m4WO%~IRS=<7+S1f^_^iF6Ef=#%9I3p%Fo{Hz<2 zhrWVjY9nEnEjj&%Dc^$=%Bc(S6lq;y^2KqP(eh%WiT=+~2;8+u$=kBYF><(k7B zk7Ah{YA!huTKNbzfPDTek^MD7y<2J_3Jjk-yM|a&w^*AMK!?i=LQL@s*~F8_f9;+S zy$i(|*GeAe9VuUl)Y)JK;2iD2#_5>k&H`bp^0x9&@T7Ot8H&s0Iq^0kuJ?TGYhb0h zUQ(N>e4_j`a2E~gC0A7ywSyeBBFEiZ@c6WJa7LW+>)F}y1}$}ix_rlg z4oy(&n2@mXN5lRF*LQ0uNsX=*F)=SQf z5@%0OQ<*oPuMOj~2bSx;?mY1|+{WyB#8IuCYF2EAgR_ zNxuXaBoq=pgJP!y?xA?r&m%fYx@D@(JKvYy7D);ohfy0o?bQ4Y8}jc zE_Z%e)(}QbV`D(nz9dEIABcw!UVkSauqk;9ZAW=t$rDPpWo!Z?@NK*wR|yv>>`GT6 z<^3em3x7G77oa$r36n0)(370uC<;$g}NiY z&K(x3t0v1l%&pTQ)T8g|1&>=OJ<#7t)cu7gi-OZ49jl5?617hEf=)3P7nc7W1|thP zEbLXHc6tz{UQ4tSPa`oTrI8rW7l*)u28$qP{eqSU1>7*j1Rfy3B?NTeNko|FVG|K1 z&cWzc#5LoG7;h_1KXemvipDKJ0Xc;d?C#<~P7!1aS2tDtAaoOG1q-V!TqqHduA~T! z$-O@-64VZ}9qyRO*+1Y7hA>L7@3)bP(L{`*oTcZNL3OnoG! zes!)lm00ak$9MCW_kxdlisskb7>fskJ}9>uiqdMtZ(79dA0gx;HcB9tZ~8*uJx=5K z0CS5<9n~e=Cm&Ww%hHAwrPrnAm{D;RsDd>?kB5ISp(eDqvZr^w77HqRL&d@HPUYP( z1``&z#Y6?a4xfP;(V&8$U6CW;e2gGB$ncvVRt4OXcvw3uW=qyaCtBZwRxL=_oiDiP z-uvh@vo+&1Gl(RPbZzt|XmSgEx#yy|%W-#V@d&udZrQjOnnqny{EtQ#7 zprck+0~rhdtrC{ocE({=SrmkO+!{V@YgZF zqHw$Jj%xQNWaAYx&${w3in%$XM?!@fau982S3bhRH0W-;qwzV)2=QWe@1R4*9-N06 z`&8C{yS>xG{-hFxC_yT5nVm7xf?Xxtku?$x`fAfD=0IOjTJv>kg-ZDkU&R3VdCg%8!Ba6!z_lJC#$7&toXI$BcF zGI;-Sal$;@nRzG8<}qdylWx9eoN~RyWHyfA!?H>Ys-sat zWdW5*03=YD$43K@L`w-s&e%=4Q8JybtMAV1Tm?NQG51uk!HJjLff*<~0VpVanGX&n z?JN46%j-P2stduuB?%QO-TX-oi_Z3CP2~oOlubGA&5r%*Zv)1%W;M%c?o!)&RR7ft z?I0e}$oKtjk|>yzh4b#ghwes3lg}ib-eLj+upsT~9S#>m&hq0`VeviL&l*Iob;0w3BJwDGs0LkGm~ybU|rkQSw4!R>s@?dcW1f#g2>`DczH5 zziP*hv2zHGd^K=&U$^zbPC1Z&B@%vBB^UJ4EZuJJ`d`oXTFbxEtV;Vg9I3bd56`wQ z7P9zA@ki3bCRw}3fI>izM`fNALOrg~KIRB)sg>=!8@IG{AgRa8lb>;DCKccrxygb! zB!@#qj}nxH*&!ir{NCj^MGV}y<_lj&sN%+D5Wwd`Jl%o8^brz7dxs9Yv;O0gWX^|n zej6qGugwCZCYN^)!77#ZYTLe* zl8P^Qo`0)upWXWzkA|Ts;Cp#ulRDK>XO;8s`ILriI6L3 zv($YpIVkNj#d1@A`kCx(Nm+5dLk+~IywPwax99t}K&i5avdqC~QWNJ=0YF+C#t%}* zLNv57FWp(xXW`%rbs^$+)Y^%>jkuYVu%L;@)Y*ty-MK=cM1G7f74X$InurQ_ z;wZsbCjcQ+6bI7yG=GLT!i2+2;xHzosGFN5M4+M8q;2E#_*Fz{#?zURz0ScQr11kb zMH&+oeD~WSBHw>HE>^5Jn}4?-cegiZ^k<)7DK)=)a& z&b>%zM}`$uI3i}uRb~jSNchM3fty}Z!#>1&c>`o|O(Y0;_CsEW zxSo$Bxc{b1xL%eX35^Mu%h;D3wEsBXKNDjPP32)=W)|nUcRf+x6ox0dJWt(gj0#>H zdYY6vUB&Zjdd_hsz8iy&)(=VF{qB8G@rmKi*2&VJUrdi*F?h)LzdnHfAK(&^W>(X{ zN%C)u5CnGgBVs>!$kGo^XW)+xSkF&G1N+15zPl~&Xd-@2ljW=_aQ5HjT$tXHugf@y zJg~3jQ}%S;etdNjc=v|FCbWZVwWWMUorX85?zaw2Y*X=;wqlx3k$)j_pEAEM_7eFi zBi4iERC<6F{t^?r+8Aj372A$2T6hQ6jFmp}%%3VwW=5AT%AplEMNJ?vp{qLvrT+63 z12$VR5Awc`yftCquBM8cJ56wBQ7Futiicsw1#AK$ck{|&eG6j_!B^Nbk1-B4{@80o zkb8uMX63>uCsQjp02%PEFaBpWjdX+Y>c+OUvJP;kH`8dF1NS&{dSA7VN4PG7| zG)wx=)CgKOJ(nEKj+_C`U_c-VbV zTA+}Z2BBNGByu)h^xC6lL?#bnVr^W8rP3_#X@K*I)^(ycKmHj8$Xa`Cjb;SNG>tP5kwm@)ZXOF&f|vsx0C3%@$8t*@+Tu?$R$jBqJ1C%> z%!Xofxdv1vBnl#8Gh8t-z4F6xtX|rNo{SJQ+rvp_;7B*WhZ;g{i|a7 z3Aqa`m*ETIS7dRn?P^-`WifrOW4^!Fy}7RtF#dhE#3_}A^~svC7^MH@WJE11p;o|+ z0&F81*IP?wjNQ?7$Xn>YjNOYsr~U+?3Ag_0+!T!~&@2hHg~_$K9sS9)GGV&mnTQ?Z z!yMO62*YZC_;s|8q7JSR<#yf5azQyn7FXERfUlpr*qmRpDEco!taiJX`z_?(c~wy znvRYsru)>6@od1=J_9F;tTVTA0jfa%wNA(Xz)DF}(BG9|HA&2V0*ZWJEXQr+*ndrs(9Tv1uqMk^?c6kt8!nOf&*Z5#Y(he} z4o`I*Qki6h+|u^fMjxmLJ=Z-9*KxiCxc!<3;sq^mp>;A0B?9N^0Z=KlL5 zRwo~!+3z`@3>qnY!h|<%|D*IJ=-9&1a%ZGdoBFM8@#&dHDR1y7%MO?eq)mPbTkGuD|sXE@7 z+d<1DrBpN2cm~_~0eT_!!<%>7xzpeFfi3Oj>& zR((wp+g>45M>o8Vn`AXM*zh!Rs;iB?4Qy(vdx5KbpkG9lYwx!w?lZmn#lCWH!oH)A z-whi^&&pHW3Tn;&_}#HQ0;Y#Pd-L)m`pXRk(_bp2M&+OP42ph=qBN&a_4Tn2?p1hBD=o( z7cDj%D$ZL_(9)**cg>^4sP5H_E8jtcqoV#?vMVP=-WWeFF{QUU9rOv2Or|lEU!w0A zlCxw3yg(XY6MtgPa59ANCukuxc#;6c6)jw?%i8!zUv7GHf<&FTt=7Xo3^EJ82wNh^ zEKHF2Yv^#^77Ry6wWX(zP5i~?!s=Ls=Tqp=Oj<9BBCLOf7c9}u`p&h=~5sgDs%Tw zp0+c}8Dy+=P#Y~OQo(gVuic}1Gk-05#QRp^Ti8II4 zb%vU?>P{|%8={Fs%zt>D647V=Ea906sEUr24&GvbO%qTD|*%N5Qk?NGB>lJS#I9 zZT+z7aD~^04!iuXP?Oze)xBW5lfV+Wvr|U@GW!ANuHP40xzhB+=8qW$%C<`<-`2~V z&SwJwmlp`QTv;akt4H~Q!uy4io|a_4|DA;meM*&3`-BC$bC`zxlZBPej5fac#Pi67 zzSfFVcB#zhFL?b$O^N7QvA6ZD6*7&hzMoApD)Gh-j!HR!OXM_`y}l?l_-W(p?^TJT zA2h31zsswPSZD#cjVHVJ77SgXqb8@v?ZbuLyV@!~xF`Voz*vzvNU?++~#tn(GEY{zL#!ahINf$?_bYM3M`DW1HJmFfevdzX;RBTK`w$HXI7$w`<#zdcR;i`UFh zmx)Y9d*x2(;*`V>FirQ5C^lLj)9E0G@-LhQa-k_h0cx|`2|Ynx2i`2X%Q$RtHxJLU zq%}h+{x@oWSe1_7Ex;WU~p>e$CFrZ=dCh+ z_#WR-Rpxb_JVA{6F*z0y$=J9{+L1wtrer>RWN8Z=1CZJWh53=!K_q3(0Ria>mmf{K zd}|)9{^~7BRbAXOaU`5zt{{FX#N3!p_=w1r@Ari?MH25+TM?DSl!2iKwG`88VVsR% z{o~ykIBFx!&B*-J<`hB`UOPxSn*J_Cm<{rO%0Z3OS6~1JAA%B>I?;ok>WOC*Khduy z1o&nY)0~E08k|(4#=WKDxJ#fJd60SJ&ebI|l&(UIH#!hp$JMBdyWx#;4nj%ZtUtelb5^dB)cLI`5XB!zb-(SG#MJym2Lw zcALScA;Ymwbc>2%UXt5~r2>g-RE&KzO&N@RGT(LWhsl$WjKTZcyCw7!Qn>Ro6LQ zCkr1BqyOC!Y6}fwda{W+(Z-OE8b|pX=DUrlmzZy8-;(<)>5-bX(>GDu z8o=UY<0CA9g$d$l(_MELt-CaUGSYKp5#yHqxULsv2P)TpV#;XOYAVZ}QYEi&+x8su(0;vn1FvxIXsS8DwnU4ZWI$B7nBs;!! zocKih{G=7aOX`BY=)f^3%~$1i_MNVA)bo!0>t)8PwIy%Ob@o~;oE567x70&X3ob#A z1T;n##So9?LJJMBB6wH&y-+bEa_`f6%oC~w zoWpu;N@&1~0?zrNJScQ`oEA$`R|!%i+M>vM^V%aZLsk*m2U@6TEUO55zu`qm^}^Kc z4k?H0+dq;v1kKx_pC&@4@86iHY!2+57dl6Grt`-aw^*#gLrb3T&dYphf=S@L?-1#i za=zc=FqfgDdkyve=G$<`GqklSC!M_3YHn;^PT`dacg)Y~%1N?|OxAA+GG-N1_Lj(e zCfi8s+rby7Oarao@HuV#G9nhd5^c;{B4%!OMNdIgnf6p4tnVS(^y0`{Ux|XJTPCN`)Mt%DJTD76Rhst2)gZ~IuVStA} z)S zTPjT1XVA1sT_!*#l!2dKRRQFMSWCruyWk45R6RnOm=XAP>q!*7q~IA4Ov5`!p@_36 zwDz?yEbCM7Ivt(dgWfrL=(uwbyK!}@fEAAR%MBHdVhnGrzeRrc5&E6cq+fN>0RdEv z>NRnqq<>jlWM}-#V!oDhMSs5bp5=UPk6XgD=Iw-Of#(!_oZ`>JzV`|=FF!BYe(za! zO-ZtG)uT%Ztyt)d=F*m^o4)P({gcizc74L4`tpdu#`C0Mr=uSiF+}Jx%})!V=AfyV z&)w^0=eY`ID}x3@Qi(@iqxnhqHnuHz>Pn*1Y|~F@-%0*nI(Uk$47#4~H?ABx7BBMd z982?4(cAA*1bLqio^dtny0FtW`mYJ}onhyvLSnJVm=SLDQBf=rIIm2^>Ae3Ut-Ly~ zyuT(;7U-V*glr&$8Y_=gi>ry&G25*&wREc~jWMlByOTzl3t=)tGv z+^Pf98k)C=-HpfQC6;V!Hyn-&W=h6#kSd4cM!Dk|DNw^y9Cja!2NU&fup&{(CH%u| z60J$X9rf(+f{Mpavm6?HwZecl&fFy$Zoa!1Wcb!0fFH~BMl2R!w)2BQ{pjgHGG(8z z<@%>6&Jq=rQxi$&)I~qCmFwbqQ8oo5f&BG~98u}56{G@&E4XJScIT3kZxqH5+bu^T zm-+7C{;#Ue0~(I*VdINcqORV8Rf82ZL87isB38E%gy_+GRv9HkNg`U5=z`TEh!#W* z(L2$D=p{k)l5cqb?K}7E%$#XwcV_PM{GPjaW5Q6Mi#}KP zgOVbjldEc`TJ=%i8Os{IxVSj|tGmxB4h7kkLnzB zss^ic1;EAB&HBK?=dE8A=xw7WOX>FtmYM}Ke&9)%4L;`ccfM{b5+|^-urE|`JUqMo zmd3n@ug{*@X~^jf3868l>9NB39lzX5jf_WerYWkN8XeQdXkz%ipK4wQZH%yr8IrZ| zz0mHgtEXsU$pYPQOc^akQ_<&AL=Az`oWZUFn*dRZN%YFXC#0dV*Wg{yR)fCE(pr&?|wH zNB`THhWVmdMHTOb1>rorOmK8yhW;nekq%mf(-|39?BJ6ah1rTIMX^7;oMm7QRF;35 z46({xxB8thdV?n*sgR*(-=LHvskVaGt|xIcD$}~Gkari$a*kI1$uYO{g8te5VwB&E z>(-;S*3+S>NB^tuh5gKvsuJt{p=>()Ve6XF(b4XWS}Sp#O)tRM@UI_6$A6h3h>3Qx z%I!riW&k!G+o`|FQ^U!T9X1EiXetz}eZT+a?A4`rydt2g%;I27z*ch{NpNq?ck%IC zz1XEk^%uF#^LEbO_qrYn>hjn+)Tq}X1+P1ZJ>;*^H;6ueym2r!W>=CE zFjsP$Ioa47Tg+N=Kzd4rV>JkVpTVx|1Z4zp>7K>g%|dhpMhxLI$wmzFR%OD0;PQWl zmurgYn6w%iyhY&@Y;L+07vdbW;~ZDqbUZ!W@3cefGfh@uQm40A;zpm?Ip8Fln~|Pc ze5Y^yB7U=l1GIaR_yjbjxe0RVIq%CY@2Xi1_Y22#G2Kb9f1!h}2Y4*WV2S}GYv*h{ z;Yds}yd5gS6RwV!fH!Ko|Dz?jZPU!>Q4!yq*&EV*i-r<1S&ph>F?3-;#4WWR?R}eq zepDAO)7nQ-B}M0;k3|OZDfq->+BMT4r#9Ghp=!TE8a4B$#6=;pyz#0-h**`&!$ku)T-EEbmId#))Ip=9PBqVyLyY8tgFi0`L{}!)mNMQ#)U&l zLs9SP2M}Dttu{F7LYef3#?#IcYyD&=^f@7P1HO+Br-I41s|h9AXQft5%%mIZ-%TW| zyfE%|MjIB}dv2-Yfo=d&?TCYs3n<70fc{smESe8QwpK_imD`O+lmlI&@-J~L;3M$_ z;X&YmV;@l;H&B?##HS@0`BXJa= z)gEcs@{w!Rx*AmYi{YDXTxxSEb-;$ji!KY&rb`Oux=se}pg4@L&`HnBzb)tzlu!nB zibMqt3$$je*uk!9kWIZ$pU{9jj6fMkyfo6#8!$cZS(#lmi^S<#=OBTAf)vwbzji$w z+}NQibMr)+*l_S>0_a-ZDY7xjWBifFxHt$K`<{6)A@aOLHa3P3O$u9dfDp0W1 zP+tLCZjfT{*HJZVi5TE#;-WMUK3h)H%A7G2*@HLvqqH+q%Edt4A90Br$#e7-w*S0X z_rhfTlKSl~sXyo9ID3o}~Q?Qq2m=|2mAc^Z5{WDNcYq;Ch>!$<_ivu!uw!ws!63g zU!BkWyU64{eRt;u^Y7F7@f3!yEvkEtTN(oIn1Lf*y2Id8X^pjs>xXxh&zI)$a7;qW z{q%vqH|)I_#4E#{U6q8B8*nf<4S}YbY?ksu;*}r{w^aw4wpE8aQ_gXGQTB^EqQela zj?$OC@BQieC4oD?$Dp_c>YbesmpJclox!PKqef{}}P|dWCpoLp)gsgDQblW4R&=DbtiPpH9Db_hh zewqa*v12Dhm)5jp2K^&Pix1+v;@eeZmxDiF^QRrB9fj40#D~P685;NRoB1@M02kl$ znJSBO1N7?k$2yKl*t7)Z(a*}c3$TPpv$H^RgxQqv`!oWP5t3HydFbgkp+ogI&31Bam>6tQXy)G`db&oH0U zwAw?S{%#q|Z+1JDBolpe&ky4~Yd3J_R5u?WOUUDJolzQHf5a)zO>g)>wC)DtJ8AcQ zZl8+ACsfxq-i@vvaH^{{Jj3V|8Lymlm@}mkH`2(t@&_^;y71FjW)PR}n_mZrr8J(d(2Wi53lnX(wOd=AnveCe#skLmrGz_8WwaB= z1TfL`IR8x_8Tp)#BpPAt6nfrD7>HZgB_#0Pnt6DUq* zAWbe5iUY-&AjPdIhT|}PAOv7g%Squ^aQT5($})j)d9QY2A~*pA3d5^6phmsPzBaIA z#0|}4$RsmIQbC9^nIJ@Pu)qTJvxp$jPfIs&Y4A``1~e%I3cc5n6g z`3g6q9ei!dk}6-y!BggPw%)bbIvgCHugKQVh)oO#yZq=y&+G+MSlyRS9&<># zd%M1d2Ojn1U8KY@>nCH3la(;58F?7M9b{I5sJ80AFx?vy@=G5X->LO>v#2~xSWYw; zn3-_+gIL0x1MaoEFPem`Y6Avscs_BwmY4tzbnznb2k$Mi{S5*eXO1>iPq*%;on{Rl zcdZ1J4fYkgjoLGxd@Jp49?_xqmZRo4va_ahw;4=)5HvI^{xd47MfdM2TST5$x$1Bq zY__|c46dm5*OpuH4W>1Q{SCXCB<(lYKgBDS9dMBCbEv)}u-DUbkJC%X^8El@_7yJ! z%GM}d&XRJ35i5qW$?TI)LlRDFq_MxN6sCewK^@mgxrpK!xvR~_ z=sojUIOH$5hb*=$EPSonbtLA3nC; zMizSh40*Wev5VYB9>ej3yJW(P(>&fh1>ShPIr(w15rW^jkJNTli6_j})$R&;AM#k+ zLv%W1I%HR!a1?p%9yx7jWS1O*Tt!)(kdIvBK}#n=Edgcc!0qPSyg%htI62Rll=wA7 z!}a24o9DdJNFR(&(2VCNXKgp1(r(?X3u_(q8zUZdZ3kFx7jJ8S-P_9HO_0OvMglpQ zqH&qy@5#qO7w=M@Od`q9JXgiK5Y2OlI4nYzQLP~=@84x9`x2wm{S!m$)-WWmeo&~a z6rx8|@a7Dax}mSp-nwsZ$p))5bTY(q#Pp?2Xg-rRt-oM*>*(>cG2AZXZlBkWH7c-e z@{>h(UwmAV>I0~e%-$a^mI0yhIzwmi2d6g`^$9l|mKwiP_c!V~OOm8L>L=K?P5nlB zH%a%@El9I$X4b`X5XX{h>~u*tuQ(!N|KPP@_`U}$k9vc0!;bnDY~xzQzHI?~1aCtm zCjzBKV8#JXYF4nWJIW&5s!_jwaLNT!K-W5FdO!E9(6nD*_abH50COPtgBGrWYxje+ z#K3`{fv{~=X*KC@Fz(Jm-{sY z)t^eHiOom8Ap8@p7R@14D5nRA{-#>ik#8tg#e`q1F49)MqdaFn>0X9fFa<;qvI9PK zFpBJBU!Cv>4ZQtjU`@TmX}|xnQvLd%;Np_NJr9?GBT{;npZxw2(28t#AI6P65s6;b zqL&U|rs&PMBf_2{cMF(c2cBatOU+&C^{nG=rgP3AcM(sXp}2t=_QGCBj$CHCOD$1~ z+_|60*pngQ4Z~kv`$se64;N{_yc;~rI#%2xJmzG*1*|6Jf4e8ms}~g3pOHL5F=u1_ zC8C~{56b+Ukc8mnA#El206q2W5VZ^V^X2EyX@dEn)N9&AJVTsA!>k2VYxBFRjY2`D z!z^<$sdC#}*{+bUY-$vjpZBVnFFM(RGdp@_N4*hH|>k3fW-j zJhTQxt%zad*op6DBc(5XA5q(#iRvdCO_RPQedSwcHkdBOSQGNpm*#`@M~89uO6!Ur z6iZTlN2NJoqcVj)U;Js*C8N{p7qGMIo?5bA)&ZtVpFS~ia*dpbWYrfVpCubSdH(!< zOe;?cEEcwVBQc1zgm*0;?@u;N!M@BjSyA9I&}pY!OOm)m(ZLdG!>8FH>MYx-*&(k6 z=c44QbXsP9y5fiz`2IVKN;BA$<<+;dlIN?;mkWly1L z17h?z3f{vXK-I6xu^xxtWi!p&7@fy73Ak^sD|1I`+$4v=-eX&tp`AVqJt2?6R5xS< zU}xc(RLCX7Js)>T?$lUe>Ic{IZ+#wWxS(65JJ94yRzG(O9n{Uvzi*<&XsK`iw93)b zrPi1YK0(e&|FovOS?cJo+^^rJ89+6;GeJO}CeKdDegBCdVMe}re}RTx{rdm@gSIUo zx%t{j#~iUvKaII8rKrs(=7|d>hj9W@k_w}BCNcpMZVG}jIx^;KLzW-`)sLaYq3%B@ekz%5X)2kvcU%}9Y8he-&7V(1V!W$361gg0e?HTpBHxxCl5Uv1 zQM-#>u_Fo|YS>L`;kR_a@l@DV4a%oJ=JZq$)D_fiAeF4WUmzEo#5AB1JrLh^tKvXJ zbX#XVW#o3H58#J=>XxV>vlUc7ojaZT&7vTYX@0vZ?$ak)^it^3m;OD3r_IQ8mNOwR z{(_mSwzuGOt*Q9t{(5hFf%*74VqEM?D$^JKT7)OveJcr%i`QQwpVy0H;`GTa759VD zee3Cma)%Ed6np*c;WsStvYu4ZshU0e(8V@8rp^h;7fiH#k~o(i{EGkJC^^1x+0>Y_+v>)e(9mrjsg5VpPNSnFM2yc=F-X%#))^BT=bG%jHvcxslz16ePVwBugI_KTr#G zAKk4!ulo(ynqD7%?dvZ@D*tk)3*ofI-=6O(0>D_>x7}(}e3y>nTvk-8)kSBkj;gXt z`F(yVJGWG{abiy^Cwn7D*Zy$g+;1F{v^%K#JJpp=lef&Hg>{y(p?T7DQGzbA_LAvL z_O8xbm$Hf5wn9$i))|lRk{3;F?{D&S+A(Q$Kl}ldhs>8BX7sdLy@%BexW_4ci>g** z*ZE5v-lxWHnGeoAeTdQtzoiqdu+9fH{d{5xqhW9Jcpi&XBO&_+hx*}L!YpAbmaq-H z3Mcb^&+-set7gJjnegvf;G-_aH!k*msvDNRE3BDAa}n?5;#tJwCK(pM`{Dgf9%0go z_5i7BdeC?E&w($cL!=cC$a6K2Dae$Vi7>-1#%wK{E=JrhxN18e)I`o{!n6K#PQVnk z`(QP?d^V^)cz>q%J84BPd(HHi6pql#?a%PE(vf!*fA=bZJNb7B`ki)55%ElEyla9wlmW$zvKNrts1jc zUjn9_Z^hAYmClE8xkLm&^k`$LTqz@2cru#JVSh89V0r~a$&4`&CBJLhHeT$G0m>B2 zof|YB?-I!T&%Ofn4&hCzDnE2#EJxufUZ{!|IF5pyx^1{qLjyNyXLYAhfmj=jhrF|$!IgiL|M;{l03)zD;RX3BLD2X!SK1UD|z=_^e+cZPg z5ME6X-*}@P`X?(zK=2DmmrAen8R9-;I5Z4)z z4Im~4_1Vu?Bh#(?gRfq@hEK8&j+^!0(g>UqeaKsAtEy${s^`4_`39Smm>f|g+yd%2!W_fGd6x?1tmFZO4f9&(OsmyW za`4sOsdpshbKk-i2R|^zK7PTq~xO?RhfyoSw>ry;N<)EJ27|Sgl~cc=ht>p z-nNS~LmBpN)vYg;SqqvYAvEXWFHtQw7N=e35=Q2R*`O+-b9!=$NAx6fD}QkykiUQN TAdEHTO8B}X)z1~73i$sATwj0E delta 266733 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

    aOA<#JDL2%xX+} zogy?g`1_yS%{6H&!|&awMFv7@ce*rRXP!!Dp%MT+RC7e)(AFh`xL{TPMkim`JU=x0 z+A1qfeT~CJnIH{rE1|&~#6HVD7+8A%&^DmQF=^0xBMrg~ZuRNWF~Tx|aKIJ+2aVKR z@Ot;ssQPtl8SuEN`5i_p1Z#3u2xfn+NXxt;mXzY&Ym4j^qtd1DC*rSw-&Z+& zt#W_%jzv27qoZQpFPxGDlr5ZAn4jQ)9snoFAwzs>g&etZRGlfTAUa_Xx31#S?1(_JG)Aw33Z_Jw_l=qN67c2&&S1a=OzMhY-ycE_A14KdAzoiV<##f^WuZ5Eh%$6+!6#=*ep zpQ>V9uOVyyJC$;S1+EnZLHh(psOuFVZ{uVqCq^~RVFYjS>8{NdgY=r*MB^olD!y*4 zp=4Q420Hzykza(^vhC-aP2jd4uAoJg``S^ET$zQ)pInlVLg}qgZqjuQx!FI}KNQZ_ zpTJIoQswr->~2vR{-vQIF`2#EColVwuv*6-dXpwx^^+u&x8RFNY+MKEgIl{q*KieHlCQ*S-hb_w!{#1s2;P1bNP-e<(a()U|Jt>vK4Ybg%0DiZ$Y;kPoe*hlUI(R*R!p6+XceSGP@w(1t|Dy9o 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 Date: Sun, 24 Sep 2023 22:20:40 +0900 Subject: [PATCH 7/7] Rectangle --- build/cache/wic.json.gz | Bin 59823 -> 59823 bytes generator.json | 6 +- .../WindowsCodecs/Structs/IWICBitmap.gen.cs | 54 ++++++------ .../Structs/IWICBitmapClipper.gen.cs | 54 ++++++------ .../Structs/IWICBitmapFlipRotator.gen.cs | 30 +++---- .../Structs/IWICBitmapFrameDecode.gen.cs | 30 +++---- .../Structs/IWICBitmapFrameEncode.gen.cs | 24 +++--- .../Structs/IWICBitmapScaler.gen.cs | 30 +++---- .../Structs/IWICBitmapSource.gen.cs | 30 +++---- .../Structs/IWICBitmapSourceTransform.gen.cs | 60 ++++++------- .../Structs/IWICColorTransform.gen.cs | 30 +++---- .../Structs/IWICDdsFrameDecode.gen.cs | 30 +++---- .../Structs/IWICDevelopRaw.gen.cs | 30 +++---- .../Structs/IWICFormatConverter.gen.cs | 30 +++---- .../IWICPlanarBitmapFrameEncode.gen.cs | 24 +++--- .../IWICPlanarBitmapSourceTransform.gen.cs | 20 ++--- .../Structs/IWICPlanarFormatConverter.gen.cs | 30 +++---- .../WindowsCodecs/Structs/Rect.gen.cs | 72 ---------------- .../WICBitmapClipperVtblExtensions.gen.cs | 68 +++++++-------- .../WICBitmapFlipRotatorVtblExtensions.gen.cs | 38 ++++----- .../WICBitmapFrameDecodeVtblExtensions.gen.cs | 38 ++++----- .../WICBitmapFrameEncodeVtblExtensions.gen.cs | 30 +++---- .../WICBitmapScalerVtblExtensions.gen.cs | 38 ++++----- ...BitmapSourceTransformVtblExtensions.gen.cs | 80 +++++++++--------- .../WICBitmapSourceVtblExtensions.gen.cs | 38 ++++----- .../Structs/WICBitmapVtblExtensions.gen.cs | 66 +++++++-------- .../WICColorTransformVtblExtensions.gen.cs | 38 ++++----- .../WICDdsFrameDecodeVtblExtensions.gen.cs | 38 ++++----- .../WICDevelopRawVtblExtensions.gen.cs | 38 ++++----- .../WICFormatConverterVtblExtensions.gen.cs | 38 ++++----- ...anarBitmapFrameEncodeVtblExtensions.gen.cs | 28 +++--- ...BitmapSourceTransformVtblExtensions.gen.cs | 26 +++--- ...PlanarFormatConverterVtblExtensions.gen.cs | 38 ++++----- 33 files changed, 577 insertions(+), 647 deletions(-) delete mode 100644 src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs diff --git a/build/cache/wic.json.gz b/build/cache/wic.json.gz index 21dba4547f3a611fa98895d19a7904c75b358117..80f25c634b44afa4001f63f418989834101bd35e 100644 GIT binary patch delta 54839 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

    dD_`t%sh=sMcz^+%n)ED!rnhR~=B{@#OQzX33^ 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 delta 54841 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" }, { "$include.commonTypeMap": "build/csharp_typemap.json" diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs index e9897a8215..1e9f7d4caa 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmap.gen.cs @@ -252,121 +252,121 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } ///

    To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, IWICBitmapLock** ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLock, flags, ppILock); return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref IWICBitmapLock* ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); } return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, IWICBitmapLock** ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcLockPtr = &prcLock) + fixed (Silk.NET.Maths.Rectangle* prcLockPtr = &prcLock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); } return ret; } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref IWICBitmapLock* ppILock) + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcLockPtr = &prcLock) + fixed (Silk.NET.Maths.Rectangle* prcLockPtr = &prcLock) { fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); } } return ret; @@ -420,7 +420,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -428,7 +428,7 @@ public readonly unsafe int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In } /// To be documented. - public readonly int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Lock([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmap*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs index 0f587363d8..94839f9966 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapClipper.gen.cs @@ -252,121 +252,121 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISource, prc); return ret; } /// To be documented. - public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) + public readonly unsafe int Initialize(IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISource, prcPtr); } return ret; } /// To be documented. - public readonly unsafe int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) + public readonly unsafe int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISourcePtr, prc); } return ret; } /// To be documented. - public readonly int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) + public readonly int Initialize(ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc) { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); } } return ret; @@ -390,7 +390,7 @@ public readonly int CopyPalette(ComPtr pIPalette) where TI0 : unmanage } /// To be documented. - public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -398,7 +398,7 @@ public readonly unsafe int Initialize(ComPtr pISource, [Flow(Silk.NET. } /// To be documented. - public readonly int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int Initialize(ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapClipper*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs index 09f0f75df4..2f291fcf14 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFlipRotator.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFlipRotator*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs index 49f04b5ae1..45e6954a36 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameDecode.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs index d360483453..6ea24562d5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapFrameEncode.gen.cs @@ -266,48 +266,48 @@ public readonly int WritePixels(uint lineCount, uint cbStride, uint cbBufferSize } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, Rect* prc) + public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, Silk.NET.Maths.Rectangle* prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSource, prc); return ret; } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, ref Rect prc) + public readonly unsafe int WriteSource(IWICBitmapSource* pIBitmapSource, ref Silk.NET.Maths.Rectangle prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(ref IWICBitmapSource pIBitmapSource, Rect* prc) + public readonly unsafe int WriteSource(ref IWICBitmapSource pIBitmapSource, Silk.NET.Maths.Rectangle* prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); } return ret; } /// To be documented. - public readonly int WriteSource(ref IWICBitmapSource pIBitmapSource, ref Rect prc) + public readonly int WriteSource(ref IWICBitmapSource pIBitmapSource, ref Silk.NET.Maths.Rectangle prc) { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); } } return ret; @@ -385,7 +385,7 @@ public readonly int SetThumbnail(ComPtr pIThumbnail) where TI0 : unman } /// To be documented. - public readonly unsafe int WriteSource(ComPtr pIBitmapSource, Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteSource(ComPtr pIBitmapSource, Silk.NET.Maths.Rectangle* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -393,7 +393,7 @@ public readonly unsafe int WriteSource(ComPtr pIBitmapSource, Rect* pr } /// To be documented. - public readonly int WriteSource(ComPtr pIBitmapSource, ref Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteSource(ComPtr pIBitmapSource, ref Silk.NET.Maths.Rectangle prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs index ba0156ceb1..e95a8b4c27 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapScaler.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapScaler*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs index 8aa7504d3c..3a97c5a8ae 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSource.gen.cs @@ -249,73 +249,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSource*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs index b1a637d2a7..ffddf5e3d3 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICBitmapSourceTransform.gen.cs @@ -111,51 +111,51 @@ public readonly uint Release() } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; @@ -163,94 +163,94 @@ public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.I { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } } @@ -258,16 +258,16 @@ public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } } diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs index 739c8919c5..fa6410875b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICColorTransform.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICColorTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs index aea710745b..cbc3e0ce85 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDdsFrameDecode.gen.cs @@ -180,73 +180,73 @@ public readonly int GetFormatInfo(ref DdsFormatInfo pFormatInfo) } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Silk.NET.Maths.Rectangle* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Silk.NET.Maths.Rectangle* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyBlocks([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDdsFrameDecode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Silk.NET.Maths.Rectangle* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs index cecd63c68f..91533fe694 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICDevelopRaw.gen.cs @@ -255,73 +255,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICDevelopRaw*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs index ef01482926..4bcd271a0c 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICFormatConverter.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs index 67e7a1538a..cf71f9587b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapFrameEncode.gen.cs @@ -132,48 +132,48 @@ public readonly int WritePixels(uint lineCount, ref BitmapPlane pPlanes, uint cP } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, Rect* prcSource) + public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, Silk.NET.Maths.Rectangle* prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); return ret; } /// To be documented. - public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, ref Rect prcSource) + public readonly unsafe int WriteSource(IWICBitmapSource** ppPlanes, uint cPlanes, ref Silk.NET.Maths.Rectangle prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, Rect* prcSource) + public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, Silk.NET.Maths.Rectangle* prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); } return ret; } /// To be documented. - public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Rect prcSource) + public readonly unsafe int WriteSource(ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Silk.NET.Maths.Rectangle prcSource) { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); } } return ret; @@ -189,7 +189,7 @@ public readonly int QueryInterface(out ComPtr ppvObject) where TI0 : u } /// To be documented. - public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlanes, Rect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlanes, Silk.NET.Maths.Rectangle* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader @@ -197,7 +197,7 @@ public readonly unsafe int WriteSource(ref ComPtr ppPlanes, uint cPlan } /// To be documented. - public readonly int WriteSource(ref ComPtr ppPlanes, uint cPlanes, ref Rect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public readonly int WriteSource(ref ComPtr ppPlanes, uint cPlanes, ref Silk.NET.Maths.Rectangle prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = (IWICPlanarBitmapFrameEncode*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); // ComPtrOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs index b5dc9bbf50..37184a0e9b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarBitmapSourceTransform.gen.cs @@ -639,48 +639,48 @@ public readonly int DoesSupportTransform(ref uint puiWidth, ref uint puiHeight, } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = (IWICPlanarBitmapSourceTransform*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs index 74dab46f33..a2e84996b1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/IWICPlanarFormatConverter.gen.cs @@ -252,73 +252,73 @@ public readonly int CopyPalette(ref IWICPalette pIPalette) } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public readonly unsafe int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public readonly int CopyPixels([Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = (IWICPlanarFormatConverter*) Unsafe.AsPointer(ref Unsafe.AsRef(in this)); int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs deleted file mode 100644 index fa6b69c6ce..0000000000 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/Rect.gen.cs +++ /dev/null @@ -1,72 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - - -using System; -using System.Runtime.InteropServices; -using System.Runtime.CompilerServices; -using System.Text; -using Silk.NET.Core; -using Silk.NET.Core.Native; -using Silk.NET.Core.Attributes; -using Silk.NET.Core.Contexts; -using Silk.NET.Core.Loader; - -#pragma warning disable 1591 - -namespace Silk.NET.WindowsCodecs -{ - [NativeName("Name", "WICRect")] - public unsafe partial struct Rect - { - public Rect - ( - int? x = null, - int? y = null, - int? width = null, - int? height = null - ) : this() - { - if (x is not null) - { - X = x.Value; - } - - if (y is not null) - { - Y = y.Value; - } - - if (width is not null) - { - Width = width.Value; - } - - if (height is not null) - { - Height = height.Value; - } - } - - - [NativeName("Type", "INT")] - [NativeName("Type.Name", "INT")] - [NativeName("Name", "X")] - public int X; - - [NativeName("Type", "INT")] - [NativeName("Type.Name", "INT")] - [NativeName("Name", "Y")] - public int Y; - - [NativeName("Type", "INT")] - [NativeName("Type.Name", "INT")] - [NativeName("Name", "Width")] - public int Width; - - [NativeName("Type", "INT")] - [NativeName("Type.Name", "INT")] - [NativeName("Name", "Height")] - public int Height; - } -} diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs index 0d6b3e69fc..0c8d464a8e 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapClipperVtblExtensions.gen.cs @@ -223,121 +223,121 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICP } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISource, prc); return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISource, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISource, prcPtr); } return ret; } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) + public static unsafe int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISourcePtr, prc); } return ret; } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) + public static int Initialize(this ComPtr thisVtbl, ref IWICBitmapSource pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pISourcePtr = &pISource) { - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[8])(@this, pISourcePtr, prcPtr); } } return ret; @@ -441,7 +441,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -449,7 +449,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Fl } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -457,7 +457,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Fl } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -465,7 +465,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -473,7 +473,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -481,7 +481,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) + public static unsafe int Initialize(this ComPtr thisVtbl, IWICBitmapSource* pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -489,7 +489,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, IWI } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Initialize(this ComPtr thisVtbl, ComPtr pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -497,7 +497,7 @@ public static int Initialize(this ComPtr thisVtbl, ComPt } /// To be documented. - public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc) + public static unsafe int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -505,7 +505,7 @@ public static unsafe int Initialize(this ComPtr thisVtbl, Spa } /// To be documented. - public static int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc) + public static int Initialize(this ComPtr thisVtbl, Span pISource, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs index 997c177e38..67c7b09192 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFlipRotatorVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref I } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -414,7 +414,7 @@ public static int CopyPalette(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -422,7 +422,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -430,7 +430,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -438,7 +438,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs index fd80139b08..e8eace71e7 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameDecodeVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref I } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -483,7 +483,7 @@ public static int CopyPalette(this ComPtr thisVtbl, Span< } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -491,7 +491,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -499,7 +499,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -507,7 +507,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs index f6b9d218f2..0f3a1407a5 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapFrameEncodeVtblExtensions.gen.cs @@ -240,48 +240,48 @@ public static int WritePixels(this ComPtr thisVtbl, uint } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Rect* prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Silk.NET.Maths.Rectangle* prc) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSource, prc); return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref Rect prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, ref Silk.NET.Maths.Rectangle prc) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSource, prcPtr); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, Rect* prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, Silk.NET.Maths.Rectangle* prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prc); } return ret; } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref Rect prc) + public static int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource pIBitmapSource, ref Silk.NET.Maths.Rectangle prc) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource* pIBitmapSourcePtr = &pIBitmapSource) { - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[11])(@this, pIBitmapSourcePtr, prcPtr); } } return ret; @@ -415,7 +415,7 @@ public static int WritePixels(this ComPtr thisVtbl, uint } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, Rect* prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, Silk.NET.Maths.Rectangle* prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -423,7 +423,7 @@ public static unsafe int WriteSource(this ComPtr thi } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource* pIBitmapSource, Span> prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -431,7 +431,7 @@ public static unsafe int WriteSource(this ComPtr thisVtbl } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref Rect prc) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteSource(this ComPtr thisVtbl, ComPtr pIBitmapSource, ref Silk.NET.Maths.Rectangle prc) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -439,7 +439,7 @@ public static int WriteSource(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Rect* prc) + public static unsafe int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Silk.NET.Maths.Rectangle* prc) { var @this = thisVtbl.Handle; // SpanOverloader @@ -447,7 +447,7 @@ public static unsafe int WriteSource(this ComPtr thisVtbl } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Span prc) + public static int WriteSource(this ComPtr thisVtbl, Span pIBitmapSource, Span> prc) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs index bc078d12af..80bf2924bc 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapScalerVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPa } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -414,7 +414,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -422,7 +422,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -430,7 +430,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -438,7 +438,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs index 45147f6bc1..f8c1e13e7b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceTransformVtblExtensions.gen.cs @@ -85,51 +85,51 @@ public static uint Release(this ComPtr thisVtbl) } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; @@ -137,94 +137,94 @@ public static unsafe int CopyPixels(this ComPtr thisV { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prc, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormat, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBuffer); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); } } } @@ -232,16 +232,16 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint uiWidth, uint uiHeight, ref Guid pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (Guid* pguidDstFormatPtr = &pguidDstFormat) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, Guid*, BitmapTransformOptions, uint, uint, byte*, int>)@this->LpVtbl[3])(@this, prcPtr, uiWidth, uiHeight, pguidDstFormatPtr, dstTransform, nStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } } @@ -364,7 +364,7 @@ public static unsafe int QueryInterface(this ComPtr t } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -372,7 +372,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -380,7 +380,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -388,7 +388,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -396,7 +396,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -404,7 +404,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -412,7 +412,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint uiWidth, uint uiHeight, Guid* pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -420,7 +420,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -428,7 +428,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -436,7 +436,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint uiWidth, uint uiHeight, Span pguidDstFormat, BitmapTransformOptions dstTransform, uint nStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs index 66d7955d98..6bdda2ea5a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapSourceVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPa } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -393,7 +393,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -401,7 +401,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -409,7 +409,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flo } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -417,7 +417,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs index 9de1ee8064..ad1852171f 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICBitmapVtblExtensions.gen.cs @@ -223,121 +223,121 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPalette } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, IWICBitmapLock** ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLock, flags, ppILock); return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref IWICBitmapLock* ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLock, flags, ppILockPtr); } return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, IWICBitmapLock** ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcLockPtr = &prcLock) + fixed (Silk.NET.Maths.Rectangle* prcLockPtr = &prcLock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILock); } return ret; } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref IWICBitmapLock* ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcLockPtr = &prcLock) + fixed (Silk.NET.Maths.Rectangle* prcLockPtr = &prcLock) { fixed (IWICBitmapLock** ppILockPtr = &ppILock) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, IWICBitmapLock**, int>)@this->LpVtbl[8])(@this, prcLockPtr, flags, ppILockPtr); } } return ret; @@ -471,7 +471,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -479,7 +479,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -487,7 +487,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -495,7 +495,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Co } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -503,7 +503,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Co } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -511,7 +511,7 @@ public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk. } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, IWICBitmapLock** ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcLock, uint flags, IWICBitmapLock** ppILock) { var @this = thisVtbl.Handle; // SpanOverloader @@ -519,7 +519,7 @@ public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.C } /// To be documented. - public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcLock, uint flags, ref ComPtr ppILock) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -527,7 +527,7 @@ public static int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Cor } /// To be documented. - public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcLock, uint flags, ref IWICBitmapLock* ppILock) + public static unsafe int Lock(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcLock, uint flags, ref IWICBitmapLock* ppILock) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs index 4cafd1bfc1..c30c8d763a 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICColorTransformVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWIC } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -633,7 +633,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -641,7 +641,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -649,7 +649,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -657,7 +657,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Sil } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs index ac33d50a42..fb6effd267 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDdsFrameDecodeVtblExtensions.gen.cs @@ -154,73 +154,73 @@ public static int GetFormatInfo(this ComPtr thisVtbl, ref Dd } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocks, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Silk.NET.Maths.Rectangle* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcBoundsInBlocks, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Silk.NET.Maths.Rectangle* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcBoundsInBlocksPtr = &prcBoundsInBlocks) + fixed (Silk.NET.Maths.Rectangle* prcBoundsInBlocksPtr = &prcBoundsInBlocks) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[5])(@this, prcBoundsInBlocksPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -284,7 +284,7 @@ public static int GetFormatInfo(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -292,7 +292,7 @@ public static unsafe int CopyBlocks(this ComPtr thisVtbl, [F } /// To be documented. - public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcBoundsInBlocks, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -300,7 +300,7 @@ public static unsafe int CopyBlocks(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcBoundsInBlocks, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -308,7 +308,7 @@ public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Sil } /// To be documented. - public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyBlocks(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcBoundsInBlocks, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs index 01dc7073ef..e33eb1c5e8 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICDevelopRawVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWICPale } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -1200,7 +1200,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1208,7 +1208,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1216,7 +1216,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow( } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -1224,7 +1224,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NE } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs index 86329e7ca9..a9088f0ea2 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICFormatConverterVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, ref IWI } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -609,7 +609,7 @@ public static int CopyPalette(this ComPtr thisVtbl, SpanTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [ } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe int CopyPixels(this ComPtr thisVtbl, [ } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -633,7 +633,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [Flow(Si } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs index 523f104bab..3d14a67ac1 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapFrameEncodeVtblExtensions.gen.cs @@ -106,48 +106,48 @@ public static int WritePixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Rect* prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Silk.NET.Maths.Rectangle* prcSource) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSource); return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Rect prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, ref Silk.NET.Maths.Rectangle prcSource) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanes, cPlanes, prcSourcePtr); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Rect* prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Silk.NET.Maths.Rectangle* prcSource) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSource); } return ret; } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Rect prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, ref Silk.NET.Maths.Rectangle prcSource) { var @this = thisVtbl.Handle; int ret = default; fixed (IWICBitmapSource** ppPlanesPtr = &ppPlanes) { - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); + ret = ((delegate* unmanaged[Stdcall]*, int>)@this->LpVtbl[4])(@this, ppPlanesPtr, cPlanes, prcSourcePtr); } } return ret; @@ -187,7 +187,7 @@ public static int WritePixels(this ComPtr thisVtbl, } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Rect* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public static unsafe int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, Silk.NET.Maths.Rectangle* prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -195,7 +195,7 @@ public static unsafe int WriteSource(this ComPtrTo be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, IWICBitmapSource** ppPlanes, uint cPlanes, Span> prcSource) { var @this = thisVtbl.Handle; // SpanOverloader @@ -203,7 +203,7 @@ public static unsafe int WriteSource(this ComPtr th } /// To be documented. - public static int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Rect prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl + public static int WriteSource(this ComPtr thisVtbl, ref ComPtr ppPlanes, uint cPlanes, ref Silk.NET.Maths.Rectangle prcSource) where TI0 : unmanaged, IComVtbl, IComVtbl { var @this = thisVtbl.Handle; // ComPtrOverloader @@ -211,7 +211,7 @@ public static int WriteSource(this ComPtr this } /// To be documented. - public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span prcSource) + public static unsafe int WriteSource(this ComPtr thisVtbl, ref IWICBitmapSource* ppPlanes, uint cPlanes, Span> prcSource) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs index c34bdf6853..ac671e1a5b 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarBitmapSourceTransformVtblExtensions.gen.cs @@ -613,48 +613,48 @@ public static int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSource, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanes, cPlanes); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in BitmapPlane pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcSourcePtr = &prcSource) + fixed (Silk.NET.Maths.Rectangle* prcSourcePtr = &prcSource) { fixed (BitmapPlane* pDstPlanesPtr = &pDstPlanes) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, BitmapTransformOptions, PlanarOptions, BitmapPlane*, uint, int>)@this->LpVtbl[4])(@this, prcSourcePtr, uiWidth, uiHeight, dstTransform, dstPlanarOptions, pDstPlanesPtr, cPlanes); } } return ret; @@ -934,7 +934,7 @@ public static int DoesSupportTransform(this ComPtrTo be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader @@ -942,7 +942,7 @@ public static unsafe int CopyPixels(this ComPtr } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] BitmapPlane* pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader @@ -950,7 +950,7 @@ public static unsafe int CopyPixels(this ComPtr } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prcSource, uint uiWidth, uint uiHeight, BitmapTransformOptions dstTransform, PlanarOptions dstPlanarOptions, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan pDstPlanes, uint cPlanes) { var @this = thisVtbl.Handle; // SpanOverloader diff --git a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs index 7fc74d5847..b998390afd 100644 --- a/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs +++ b/src/Microsoft/Silk.NET.Direct2D/WindowsCodecs/Structs/WICPlanarFormatConverterVtblExtensions.gen.cs @@ -223,73 +223,73 @@ public static int CopyPalette(this ComPtr thisVtbl, r } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBuffer); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); } return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prc, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); return ret; } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBuffer); } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, ref byte pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { fixed (byte* pbBufferPtr = &pbBuffer) { - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); } } return ret; } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Rect prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] in Silk.NET.Maths.Rectangle prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; int ret = default; - fixed (Rect* prcPtr = &prc) + fixed (Silk.NET.Maths.Rectangle* prcPtr = &prc) { var pbBufferPtr = (byte*) SilkMarshal.StringToPtr(pbBuffer, NativeStringEncoding.UTF8); - ret = ((delegate* unmanaged[Stdcall])@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); + ret = ((delegate* unmanaged[Stdcall]*, uint, uint, byte*, int>)@this->LpVtbl[7])(@this, prcPtr, cbStride, cbBufferSize, pbBufferPtr); SilkMarshal.Free((nint)pbBufferPtr); } return ret; @@ -609,7 +609,7 @@ public static int CopyPalette(this ComPtr thisVtbl, S } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Rect* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] Silk.NET.Maths.Rectangle* prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -617,7 +617,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) + public static unsafe int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, byte* pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -625,7 +625,7 @@ public static unsafe int CopyPixels(this ComPtr thisV } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, Span pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, Span pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader @@ -633,7 +633,7 @@ public static int CopyPixels(this ComPtr thisVtbl, [F } /// To be documented. - public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) + public static int CopyPixels(this ComPtr thisVtbl, [Flow(Silk.NET.Core.Native.FlowDirection.In)] ReadOnlySpan> prc, uint cbStride, uint cbBufferSize, [UnmanagedType(Silk.NET.Core.Native.UnmanagedType.LPUTF8Str)] string pbBuffer) { var @this = thisVtbl.Handle; // SpanOverloader

    • }4rn7S9he#D(lFhDK5v9E^rwf(~O> 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